mantarimay/Aegisub
1
0
Fork 0
forked from mia/Aegisub
Code Pull requests Activity

Update to the latest ffms (r116) from http://code.google.com/p/ffmpegsource/.

Browse source 
Originally committed to SVN as r3115.
This commit is contained in:
Amar Takhar 2009-07-13 22:27:40 +00:00
parent 24be06341a
commit 5dc912bf4d
63 changed files with 8944 additions and 5147 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

749
aegisub/libffms/avisynth.h
View file

@ -1,749 +0,0 @@
// Avisynth v2.5. Copyright 2002 Ben Rudiak-Gould et al.
// http://www.avisynth.org
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA, or visit
// http://www.gnu.org/copyleft/gpl.html .
//
// Linking Avisynth statically or dynamically with other modules is making a
// combined work based on Avisynth. Thus, the terms and conditions of the GNU
// General Public License cover the whole combination.
//
// As a special exception, the copyright holders of Avisynth give you
// permission to link Avisynth with independent modules that communicate with
// Avisynth solely through the interfaces defined in avisynth.h, regardless of the license
// terms of these independent modules, and to copy and distribute the
// resulting combined work under terms of your choice, provided that
// every copy of the combined work is accompanied by a complete copy of
// the source code of Avisynth (the version of Avisynth used to produce the
// combined work), being distributed under the terms of the GNU General
// Public License plus this exception. An independent module is a module
// which is not derived from or based on Avisynth, such as 3rd-party filters,
// import and export plugins, or graphical user interfaces.
#ifndef __AVISYNTH_H__
#define __AVISYNTH_H__
enum { AVISYNTH_INTERFACE_VERSION = 3 };
/* Define all types necessary for interfacing with avisynth.dll
Moved from internal.h */
// Win32 API macros, notably the types BYTE, DWORD, ULONG, etc.
#include <windef.h>
// COM interface macros
#include <objbase.h>
// Raster types used by VirtualDub & Avisynth
#define in64 (__int64)(unsigned short)
typedef unsigned long Pixel; // this will break on 64-bit machines!
typedef unsigned long Pixel32;
typedef unsigned char Pixel8;
typedef long PixCoord;
typedef long PixDim;
typedef long PixOffset;
/* Compiler-specific crap */
// Tell MSVC to stop precompiling here
#ifdef _MSC_VER
#pragma hdrstop
#endif
// Set up debugging macros for MS compilers; for others, step down to the
// standard <assert.h> interface
#ifdef _MSC_VER
#include <crtdbg.h>
#else
#define _RPT0(a,b) ((void)0)
#define _RPT1(a,b,c) ((void)0)
#define _RPT2(a,b,c,d) ((void)0)
#define _RPT3(a,b,c,d,e) ((void)0)
#define _RPT4(a,b,c,d,e,f) ((void)0)
#define _ASSERTE(x) assert(x)
#include <assert.h>
#endif
// I had problems with Premiere wanting 1-byte alignment for its structures,
// so I now set the Avisynth struct alignment explicitly here.
#pragma pack(push,8)
#define FRAME_ALIGN 16
// Default frame alignment is 16 bytes, to help P4, when using SSE2
// The VideoInfo struct holds global information about a clip (i.e.
// information that does not depend on the frame number). The GetVideoInfo
// method in IClip returns this struct.
// Audio Sample information
typedef float SFLOAT;
enum {SAMPLE_INT8 = 1<<0,
SAMPLE_INT16 = 1<<1,
SAMPLE_INT24 = 1<<2, // Int24 is a very stupid thing to code, but it's supported by some hardware.
SAMPLE_INT32 = 1<<3,
SAMPLE_FLOAT = 1<<4};
enum {
PLANAR_Y=1<<0,
PLANAR_U=1<<1,
PLANAR_V=1<<2,
PLANAR_ALIGNED=1<<3,
PLANAR_Y_ALIGNED=PLANAR_Y|PLANAR_ALIGNED,
PLANAR_U_ALIGNED=PLANAR_U|PLANAR_ALIGNED,
PLANAR_V_ALIGNED=PLANAR_V|PLANAR_ALIGNED,
};
struct VideoInfo {
int width, height; // width=0 means no video
unsigned fps_numerator, fps_denominator;
int num_frames;
// This is more extensible than previous versions. More properties can be added seeminglesly.
// Colorspace properties.
enum {
CS_BGR = 1<<28,
CS_YUV = 1<<29,
CS_INTERLEAVED = 1<<30,
CS_PLANAR = 1<<31
};
// Specific colorformats
enum { CS_UNKNOWN = 0,
CS_BGR24 = 1<<0 | CS_BGR | CS_INTERLEAVED,
CS_BGR32 = 1<<1 | CS_BGR | CS_INTERLEAVED,
CS_YUY2 = 1<<2 | CS_YUV | CS_INTERLEAVED,
CS_YV12 = 1<<3 | CS_YUV | CS_PLANAR, // y-v-u, planar
CS_I420 = 1<<4 | CS_YUV | CS_PLANAR, // y-u-v, planar
CS_IYUV = 1<<4 | CS_YUV | CS_PLANAR // same as above
};
int pixel_type; // changed to int as of 2.5
int audio_samples_per_second; // 0 means no audio
int sample_type; // as of 2.5
__int64 num_audio_samples; // changed as of 2.5
int nchannels; // as of 2.5
// Imagetype properties
int image_type;
enum {
IT_BFF = 1<<0,
IT_TFF = 1<<1,
IT_FIELDBASED = 1<<2
};
// useful functions of the above
bool HasVideo() const { return (width!=0); }
bool HasAudio() const { return (audio_samples_per_second!=0); }
bool IsRGB() const { return !!(pixel_type&CS_BGR); }
bool IsRGB24() const { return (pixel_type&CS_BGR24)==CS_BGR24; } // Clear out additional properties
bool IsRGB32() const { return (pixel_type & CS_BGR32) == CS_BGR32 ; }
bool IsYUV() const { return !!(pixel_type&CS_YUV ); }
bool IsYUY2() const { return (pixel_type & CS_YUY2) == CS_YUY2; }
bool IsYV12() const { return ((pixel_type & CS_YV12) == CS_YV12)||((pixel_type & CS_I420) == CS_I420); }
bool IsColorSpace(int c_space) const { return ((pixel_type & c_space) == c_space); }
bool Is(int property) const { return ((pixel_type & property)==property ); }
bool IsPlanar() const { return !!(pixel_type & CS_PLANAR); }
bool IsFieldBased() const { return !!(image_type & IT_FIELDBASED); }
bool IsParityKnown() const { return ((image_type & IT_FIELDBASED)&&(image_type & (IT_BFF|IT_TFF))); }
bool IsBFF() const { return !!(image_type & IT_BFF); }
bool IsTFF() const { return !!(image_type & IT_TFF); }
bool IsVPlaneFirst() const {return ((pixel_type & CS_YV12) == CS_YV12); } // Don't use this
int BytesFromPixels(int pixels) const { return pixels * (BitsPerPixel()>>3); } // Will not work on planar images, but will return only luma planes
int RowSize() const { return BytesFromPixels(width); } // Also only returns first plane on planar images
int BMPSize() const { if (IsPlanar()) {int p = height * ((RowSize()+3) & ~3); p+=p>>1; return p; } return height * ((RowSize()+3) & ~3); }
__int64 AudioSamplesFromFrames(__int64 frames) const { return (fps_numerator && HasVideo()) ? ((__int64)(frames) * audio_samples_per_second * fps_denominator / fps_numerator) : 0; }
int FramesFromAudioSamples(__int64 samples) const { return (fps_denominator && HasAudio()) ? (int)((samples * (__int64)fps_numerator)/((__int64)fps_denominator * (__int64)audio_samples_per_second)) : 0; }
__int64 AudioSamplesFromBytes(__int64 bytes) const { return HasAudio() ? bytes / BytesPerAudioSample() : 0; }
__int64 BytesFromAudioSamples(__int64 samples) const { return samples * BytesPerAudioSample(); }
int AudioChannels() const { return HasAudio() ? nchannels : 0; }
int SampleType() const{ return sample_type;}
bool IsSampleType(int testtype) const{ return !!(sample_type&testtype);}
int SamplesPerSecond() const { return audio_samples_per_second; }
int BytesPerAudioSample() const { return nchannels*BytesPerChannelSample();}
void SetFieldBased(bool isfieldbased) { if (isfieldbased) image_type|=IT_FIELDBASED; else image_type&=~IT_FIELDBASED; }
void Set(int property) { image_type|=property; }
void Clear(int property) { image_type&=~property; }
int BitsPerPixel() const {
switch (pixel_type) {
case CS_BGR24:
return 24;
case CS_BGR32:
return 32;
case CS_YUY2:
return 16;
case CS_YV12:
case CS_I420:
return 12;
default:
return 0;
}
}
int BytesPerChannelSample() const {
switch (sample_type) {
case SAMPLE_INT8:
return sizeof(signed char);
case SAMPLE_INT16:
return sizeof(signed short);
case SAMPLE_INT24:
return 3;
case SAMPLE_INT32:
return sizeof(signed int);
case SAMPLE_FLOAT:
return sizeof(SFLOAT);
default:
_ASSERTE("Sample type not recognized!");
return 0;
}
}
// useful mutator
void SetFPS(unsigned numerator, unsigned denominator) {
if ((numerator == 0) || (denominator == 0)) {
fps_numerator = 0;
fps_denominator = 1;
}
else {
unsigned x=numerator, y=denominator;
while (y) { // find gcd
unsigned t = x%y; x = y; y = t;
}
fps_numerator = numerator/x;
fps_denominator = denominator/x;
}
}
// Range protected multiply-divide of FPS
void MulDivFPS(unsigned multiplier, unsigned divisor) {
unsigned __int64 numerator = UInt32x32To64(fps_numerator, multiplier);
unsigned __int64 denominator = UInt32x32To64(fps_denominator, divisor);
unsigned __int64 x=numerator, y=denominator;
while (y) { // find gcd
unsigned __int64 t = x%y; x = y; y = t;
}
numerator /= x; // normalize
denominator /= x;
unsigned __int64 temp = numerator | denominator; // Just looking top bit
unsigned u = 0;
while (temp & 0xffffffff80000000) { // or perhaps > 16777216*2
temp = Int64ShrlMod32(temp, 1);
u++;
}
if (u) { // Scale to fit
const unsigned round = 1 << (u-1);
SetFPS( (unsigned)Int64ShrlMod32(numerator + round, u),
(unsigned)Int64ShrlMod32(denominator + round, u) );
}
else {
fps_numerator = (unsigned)numerator;
fps_denominator = (unsigned)denominator;
}
}
// Test for same colorspace
bool IsSameColorspace(const VideoInfo& vi) const {
if (vi.pixel_type == pixel_type) return TRUE;
if (IsYV12() && vi.IsYV12()) return TRUE;
return FALSE;
}
};
// VideoFrameBuffer holds information about a memory block which is used
// for video data. For efficiency, instances of this class are not deleted
// when the refcount reaches zero; instead they're stored in a linked list
// to be reused. The instances are deleted when the corresponding AVS
// file is closed.
class VideoFrameBuffer {
BYTE* const data;
const int data_size;
// sequence_number is incremented every time the buffer is changed, so
// that stale views can tell they're no longer valid.
long sequence_number;
friend class VideoFrame;
friend class Cache;
friend class ScriptEnvironment;
long refcount;
public:
VideoFrameBuffer(int size);
VideoFrameBuffer();
~VideoFrameBuffer();
const BYTE* GetReadPtr() const { return data; }
BYTE* GetWritePtr() { ++sequence_number; return data; }
int GetDataSize() { return data_size; }
int GetSequenceNumber() { return sequence_number; }
int GetRefcount() { return refcount; }
};
class IClip;
class PClip;
class PVideoFrame;
class IScriptEnvironment;
class AVSValue;
// VideoFrame holds a "window" into a VideoFrameBuffer. Operator new
// is overloaded to recycle class instances.
class VideoFrame {
int refcount;
VideoFrameBuffer* const vfb;
const int offset, pitch, row_size, height, offsetU, offsetV, pitchUV; // U&V offsets are from top of picture.
friend class PVideoFrame;
void AddRef() { InterlockedIncrement((long *)&refcount); }
void Release() { if (refcount==1) InterlockedDecrement(&vfb->refcount); InterlockedDecrement((long *)&refcount); }
friend class ScriptEnvironment;
friend class Cache;
VideoFrame(VideoFrameBuffer* _vfb, int _offset, int _pitch, int _row_size, int _height);
VideoFrame(VideoFrameBuffer* _vfb, int _offset, int _pitch, int _row_size, int _height, int _offsetU, int _offsetV, int _pitchUV);
void* operator new(unsigned size);
// TESTME: OFFSET U/V may be switched to what could be expected from AVI standard!
public:
int GetPitch() const { return pitch; }
int GetPitch(int plane) const { switch (plane) {case PLANAR_U: case PLANAR_V: return pitchUV;} return pitch; }
int GetRowSize() const { return row_size; }
int GetRowSize(int plane) const {
switch (plane) {
case PLANAR_U: case PLANAR_V: if (pitchUV) return row_size>>1; else return 0;
case PLANAR_U_ALIGNED: case PLANAR_V_ALIGNED:
if (pitchUV) {
int r = ((row_size+FRAME_ALIGN-1)&(~(FRAME_ALIGN-1)) )>>1; // Aligned rowsize
if (r<=pitchUV)
return r;
return row_size>>1;
} else return 0;
case PLANAR_Y_ALIGNED:
int r = (row_size+FRAME_ALIGN-1)&(~(FRAME_ALIGN-1)); // Aligned rowsize
if (r<=pitch)
return r;
return row_size;
}
return row_size; }
int GetHeight() const { return height; }
int GetHeight(int plane) const { switch (plane) {case PLANAR_U: case PLANAR_V: if (pitchUV) return height>>1; return 0;} return height; }
// generally you shouldn't use these three
VideoFrameBuffer* GetFrameBuffer() const { return vfb; }
int GetOffset() const { return offset; }
int GetOffset(int plane) const { switch (plane) {case PLANAR_U: return offsetU;case PLANAR_V: return offsetV;default: return offset;}; }
// in plugins use env->SubFrame()
VideoFrame* Subframe(int rel_offset, int new_pitch, int new_row_size, int new_height) const;
VideoFrame* Subframe(int rel_offset, int new_pitch, int new_row_size, int new_height, int rel_offsetU, int rel_offsetV, int pitchUV) const;
const BYTE* GetReadPtr() const { return vfb->GetReadPtr() + offset; }
const BYTE* GetReadPtr(int plane) const { return vfb->GetReadPtr() + GetOffset(plane); }
bool IsWritable() const { return (refcount == 1 && vfb->refcount == 1); }
BYTE* GetWritePtr() const {
if (vfb->GetRefcount()>1) {
_ASSERT(FALSE);
//throw AvisynthError("Internal Error - refcount was more than one!");
}
return IsWritable() ? (vfb->GetWritePtr() + offset) : 0;
}
BYTE* GetWritePtr(int plane) const {
if (plane==PLANAR_Y) {
if (vfb->GetRefcount()>1) {
_ASSERT(FALSE);
// throw AvisynthError("Internal Error - refcount was more than one!");
}
return IsWritable() ? vfb->GetWritePtr() + GetOffset(plane) : 0;
}
return vfb->data + GetOffset(plane);
}
~VideoFrame() { InterlockedDecrement(&vfb->refcount); }
};
enum {
CACHE_NOTHING=0,
CACHE_RANGE=1,
CACHE_ALL=2,
CACHE_AUDIO=3,
CACHE_AUDIO_NONE=4
};
// Base class for all filters.
class IClip {
friend class PClip;
friend class AVSValue;
int refcnt;
void AddRef() { InterlockedIncrement((long *)&refcnt); }
void Release() { InterlockedDecrement((long *)&refcnt); if (!refcnt) delete this; }
public:
IClip() : refcnt(0) {}
virtual int __stdcall GetVersion() { return AVISYNTH_INTERFACE_VERSION; }
virtual PVideoFrame __stdcall GetFrame(int n, IScriptEnvironment* env) = 0;
virtual bool __stdcall GetParity(int n) = 0; // return field parity if field_based, else parity of first field in frame
virtual void __stdcall GetAudio(void* buf, __int64 start, __int64 count, IScriptEnvironment* env) = 0; // start and count are in samples
virtual void __stdcall SetCacheHints(int cachehints,int frame_range) = 0 ; // We do not pass cache requests upwards, only to the next filter.
virtual const VideoInfo& __stdcall GetVideoInfo() = 0;
virtual __stdcall ~IClip() {}
};
// smart pointer to IClip
class PClip {
IClip* p;
IClip* GetPointerWithAddRef() const { if (p) p->AddRef(); return p; }
friend class AVSValue;
friend class VideoFrame;
void Init(IClip* x) {
if (x) x->AddRef();
p=x;
}
void Set(IClip* x) {
if (x) x->AddRef();
if (p) p->Release();
p=x;
}
public:
PClip() { p = 0; }
PClip(const PClip& x) { Init(x.p); }
PClip(IClip* x) { Init(x); }
void operator=(IClip* x) { Set(x); }
void operator=(const PClip& x) { Set(x.p); }
IClip* operator->() const { return p; }
// useful in conditional expressions
operator void*() const { return p; }
bool operator!() const { return !p; }
~PClip() { if (p) p->Release(); }
};
// smart pointer to VideoFrame
class PVideoFrame {
VideoFrame* p;
void Init(VideoFrame* x) {
if (x) x->AddRef();
p=x;
}
void Set(VideoFrame* x) {
if (x) x->AddRef();
if (p) p->Release();
p=x;
}
public:
PVideoFrame() { p = 0; }
PVideoFrame(const PVideoFrame& x) { Init(x.p); }
PVideoFrame(VideoFrame* x) { Init(x); }
void operator=(VideoFrame* x) { Set(x); }
void operator=(const PVideoFrame& x) { Set(x.p); }
VideoFrame* operator->() const { return p; }
// for conditional expressions
operator void*() const { return p; }
bool operator!() const { return !p; }
~PVideoFrame() { if (p) p->Release();}
};
class AVSValue {
public:
AVSValue() { type = 'v'; }
AVSValue(IClip* c) { type = 'c'; clip = c; if (c) c->AddRef(); }
AVSValue(const PClip& c) { type = 'c'; clip = c.GetPointerWithAddRef(); }
AVSValue(bool b) { type = 'b'; boolean = b; }
AVSValue(int i) { type = 'i'; integer = i; }
// AVSValue(__int64 l) { type = 'l'; longlong = l; }
AVSValue(float f) { type = 'f'; floating_pt = f; }
AVSValue(double f) { type = 'f'; floating_pt = float(f); }
AVSValue(const char* s) { type = 's'; string = s; }
AVSValue(const AVSValue* a, int size) { type = 'a'; array = a; array_size = size; }
AVSValue(const AVSValue& v) { Assign(&v, true); }
~AVSValue() { if (IsClip() && clip) clip->Release(); }
AVSValue& operator=(const AVSValue& v) { Assign(&v, false); return *this; }
// Note that we transparently allow 'int' to be treated as 'float'.
// There are no int<->bool conversions, though.
bool Defined() const { return type != 'v'; }
bool IsClip() const { return type == 'c'; }
bool IsBool() const { return type == 'b'; }
bool IsInt() const { return type == 'i'; }
// bool IsLong() const { return (type == 'l'|| type == 'i'); }
bool IsFloat() const { return type == 'f' || type == 'i'; }
bool IsString() const { return type == 's'; }
bool IsArray() const { return type == 'a'; }
PClip AsClip() const { _ASSERTE(IsClip()); return IsClip()?clip:0; }
bool AsBool() const { _ASSERTE(IsBool()); return boolean; }
int AsInt() const { _ASSERTE(IsInt()); return integer; }
// int AsLong() const { _ASSERTE(IsLong()); return longlong; }
const char* AsString() const { _ASSERTE(IsString()); return IsString()?string:0; }
double AsFloat() const { _ASSERTE(IsFloat()); return IsInt()?integer:floating_pt; }
bool AsBool(bool def) const { _ASSERTE(IsBool()||!Defined()); return IsBool() ? boolean : def; }
int AsInt(int def) const { _ASSERTE(IsInt()||!Defined()); return IsInt() ? integer : def; }
double AsFloat(double def) const { _ASSERTE(IsFloat()||!Defined()); return IsInt() ? integer : type=='f' ? floating_pt : def; }
const char* AsString(const char* def) const { _ASSERTE(IsString()||!Defined()); return IsString() ? string : def; }
int ArraySize() const { _ASSERTE(IsArray()); return IsArray()?array_size:1; }
const AVSValue& operator[](int index) const {
_ASSERTE(IsArray() && index>=0 && index<array_size);
return (IsArray() && index>=0 && index<array_size) ? array[index] : *this;
}
private:
short type; // 'a'rray, 'c'lip, 'b'ool, 'i'nt, 'f'loat, 's'tring, 'v'oid, or 'l'ong
short array_size;
union {
IClip* clip;
bool boolean;
int integer;
float floating_pt;
const char* string;
const AVSValue* array;
// __int64 longlong;
};
void Assign(const AVSValue* src, bool init) {
if (src->IsClip() && src->clip)
src->clip->AddRef();
if (!init && IsClip() && clip)
clip->Release();
// make sure this copies the whole struct!
((__int32*)this)[0] = ((__int32*)src)[0];
((__int32*)this)[1] = ((__int32*)src)[1];
}
};
// instantiable null filter
class GenericVideoFilter : public IClip {
protected:
PClip child;
VideoInfo vi;
public:
GenericVideoFilter(PClip _child) : child(_child) { vi = child->GetVideoInfo(); }
PVideoFrame __stdcall GetFrame(int n, IScriptEnvironment* env) { return child->GetFrame(n, env); }
void __stdcall GetAudio(void* buf, __int64 start, __int64 count, IScriptEnvironment* env) { child->GetAudio(buf, start, count, env); }
const VideoInfo& __stdcall GetVideoInfo() { return vi; }
bool __stdcall GetParity(int n) { return child->GetParity(n); }
void __stdcall SetCacheHints(int cachehints,int frame_range) { } ; // We do not pass cache requests upwards, only to the next filter.
};
class AvisynthError /* exception */ {
public:
const char* const msg;
AvisynthError(const char* _msg) : msg(_msg) {}
};
/* Helper classes useful to plugin authors */
class AlignPlanar : public GenericVideoFilter
{
public:
AlignPlanar(PClip _clip);
static PClip Create(PClip clip);
PVideoFrame __stdcall GetFrame(int n, IScriptEnvironment* env);
};
class FillBorder : public GenericVideoFilter
{
public:
FillBorder(PClip _clip);
static PClip Create(PClip clip);
PVideoFrame __stdcall GetFrame(int n, IScriptEnvironment* env);
};
class ConvertAudio : public GenericVideoFilter
/**
* Helper class to convert audio to any format
**/
{
public:
ConvertAudio(PClip _clip, int prefered_format);
void __stdcall GetAudio(void* buf, __int64 start, __int64 count, IScriptEnvironment* env);
void __stdcall SetCacheHints(int cachehints,int frame_range); // We do pass cache requests upwards, to the cache!
static PClip Create(PClip clip, int sample_type, int prefered_type);
static AVSValue __cdecl Create_float(AVSValue args, void*, IScriptEnvironment*);
static AVSValue __cdecl Create_32bit(AVSValue args, void*, IScriptEnvironment*);
static AVSValue __cdecl Create_24bit(AVSValue args, void*, IScriptEnvironment*);
static AVSValue __cdecl Create_16bit(AVSValue args, void*, IScriptEnvironment*);
static AVSValue __cdecl Create_8bit(AVSValue args, void*, IScriptEnvironment*);
virtual ~ConvertAudio();
private:
void convertToFloat(char* inbuf, float* outbuf, char sample_type, int count);
void convertToFloat_3DN(char* inbuf, float* outbuf, char sample_type, int count);
void convertToFloat_SSE(char* inbuf, float* outbuf, char sample_type, int count);
void convertToFloat_SSE2(char* inbuf, float* outbuf, char sample_type, int count);
void convertFromFloat(float* inbuf, void* outbuf, char sample_type, int count);
void convertFromFloat_3DN(float* inbuf, void* outbuf, char sample_type, int count);
void convertFromFloat_SSE(float* inbuf, void* outbuf, char sample_type, int count);
void convertFromFloat_SSE2(float* inbuf, void* outbuf, char sample_type, int count);
__inline int Saturate_int8(float n);
__inline short Saturate_int16(float n);
__inline int Saturate_int24(float n);
__inline int Saturate_int32(float n);
char src_format;
char dst_format;
int src_bps;
char *tempbuffer;
SFLOAT *floatbuffer;
int tempbuffer_size;
};
// For GetCPUFlags. These are backwards-compatible with those in VirtualDub.
enum {
/* slowest CPU to support extension */
CPUF_FORCE = 0x01, // N/A
CPUF_FPU = 0x02, // 386/486DX
CPUF_MMX = 0x04, // P55C, K6, PII
CPUF_INTEGER_SSE = 0x08, // PIII, Athlon
CPUF_SSE = 0x10, // PIII, Athlon XP/MP
CPUF_SSE2 = 0x20, // PIV, Hammer
CPUF_3DNOW = 0x40, // K6-2
CPUF_3DNOW_EXT = 0x80, // Athlon
CPUF_X86_64 = 0xA0, // Hammer (note: equiv. to 3DNow + SSE2, which only Hammer
// will have anyway)
CPUF_SSE3 = 0x100, // Some P4 & Athlon 64.
};
#define MAX_INT 0x7fffffff
#define MIN_INT -0x7fffffff
class IScriptEnvironment {
public:
virtual __stdcall ~IScriptEnvironment() {}
virtual /*static*/ long __stdcall GetCPUFlags() = 0;
virtual char* __stdcall SaveString(const char* s, int length = -1) = 0;
virtual char* __stdcall Sprintf(const char* fmt, ...) = 0;
// note: val is really a va_list; I hope everyone typedefs va_list to a pointer
virtual char* __stdcall VSprintf(const char* fmt, void* val) = 0;
__declspec(noreturn) virtual void __stdcall ThrowError(const char* fmt, ...) = 0;
class NotFound /*exception*/ {}; // thrown by Invoke and GetVar
typedef AVSValue (__cdecl *ApplyFunc)(AVSValue args, void* user_data, IScriptEnvironment* env);
virtual void __stdcall AddFunction(const char* name, const char* params, ApplyFunc apply, void* user_data) = 0;
virtual bool __stdcall FunctionExists(const char* name) = 0;
virtual AVSValue __stdcall Invoke(const char* name, const AVSValue args, const char** arg_names=0) = 0;
virtual AVSValue __stdcall GetVar(const char* name) = 0;
virtual bool __stdcall SetVar(const char* name, const AVSValue& val) = 0;
virtual bool __stdcall SetGlobalVar(const char* name, const AVSValue& val) = 0;
virtual void __stdcall PushContext(int level=0) = 0;
virtual void __stdcall PopContext() = 0;
// align should be 4 or 8
virtual PVideoFrame __stdcall NewVideoFrame(const VideoInfo& vi, int align=FRAME_ALIGN) = 0;
virtual bool __stdcall MakeWritable(PVideoFrame* pvf) = 0;
virtual /*static*/ void __stdcall BitBlt(BYTE* dstp, int dst_pitch, const BYTE* srcp, int src_pitch, int row_size, int height) = 0;
typedef void (__cdecl *ShutdownFunc)(void* user_data, IScriptEnvironment* env);
virtual void __stdcall AtExit(ShutdownFunc function, void* user_data) = 0;
virtual void __stdcall CheckVersion(int version = AVISYNTH_INTERFACE_VERSION) = 0;
virtual PVideoFrame __stdcall Subframe(PVideoFrame src, int rel_offset, int new_pitch, int new_row_size, int new_height) = 0;
virtual int __stdcall SetMemoryMax(int mem) = 0;
virtual int __stdcall SetWorkingDir(const char * newdir) = 0;
virtual void* __stdcall ManageCache(int key, void* data) = 0;
enum PlanarChromaAlignmentMode {
PlanarChromaAlignmentOff,
PlanarChromaAlignmentOn,
PlanarChromaAlignmentTest };
virtual bool __stdcall PlanarChromaAlignment(PlanarChromaAlignmentMode key) = 0;
virtual PVideoFrame __stdcall SubframePlanar(PVideoFrame src, int rel_offset, int new_pitch, int new_row_size, int new_height, int rel_offsetU, int rel_offsetV, int new_pitchUV) = 0;
};
// avisynth.dll exports this; it's a way to use it as a library, without
// writing an AVS script or without going through AVIFile.
IScriptEnvironment* __stdcall CreateScriptEnvironment(int version = AVISYNTH_INTERFACE_VERSION);
#pragma pack(pop)
#endif //__AVISYNTH_H__

719
aegisub/libffms/ffaudiosource.cpp
View file

@ -1,719 +0,0 @@
// Copyright (c) 2007-2009 Fredrik Mellbin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include "ffaudiosource.h"
#include <errno.h>
#ifdef __UNIX__
#define _snprintf snprintf
#endif
TAudioBlock::TAudioBlock(int64_t Start, int64_t Samples, uint8_t *SrcData, size_t SrcBytes) {
this->Start = Start;
this->Samples = Samples;
Data = new uint8_t[SrcBytes];
memcpy(Data, SrcData, SrcBytes);
}
TAudioBlock::~TAudioBlock() {
delete[] Data;
}
TAudioCache::TAudioCache() {
MaxCacheBlocks = 0;
BytesPerSample = 0;
}
TAudioCache::~TAudioCache() {
for (TAudioCache::iterator it=begin(); it != end(); it++)
delete *it;
}
void TAudioCache::Initialize(int BytesPerSample, int MaxCacheBlocks) {
this->BytesPerSample = BytesPerSample;
this->MaxCacheBlocks = MaxCacheBlocks;
}
void TAudioCache::CacheBlock(int64_t Start, int64_t Samples, uint8_t *SrcData) {
if (BytesPerSample > 0) {
for (TAudioCache::iterator it=begin(); it != end(); it++) {
if ((*it)->Start == Start) {
delete *it;
erase(it);
break;
}
}
push_front(new TAudioBlock(Start, Samples, SrcData, Samples * BytesPerSample));
if (static_cast<int>(size()) >= MaxCacheBlocks) {
delete back();
pop_back();
}
}
}
bool TAudioCache::AudioBlockComp(TAudioBlock *A, TAudioBlock *B) {
return A->Start < B->Start;
}
int64_t TAudioCache::FillRequest(int64_t Start, int64_t Samples, uint8_t *Dst) {
// May be better to move used blocks to the front
std::list<TAudioBlock *> UsedBlocks;
for (TAudioCache::iterator it=begin(); it != end(); it++) {
int64_t SrcOffset = FFMAX(0, Start - (*it)->Start);
int64_t DstOffset = FFMAX(0, (*it)->Start - Start);
int64_t CopySamples = FFMIN((*it)->Samples - SrcOffset, Samples - DstOffset);
if (CopySamples > 0) {
memcpy(Dst + DstOffset * BytesPerSample, (*it)->Data + SrcOffset * BytesPerSample, CopySamples * BytesPerSample);
UsedBlocks.push_back(*it);
}
}
UsedBlocks.sort(AudioBlockComp);
int64_t Ret = Start;
for (std::list<TAudioBlock *>::iterator it = UsedBlocks.begin(); it != UsedBlocks.end(); it++) {
if (it == UsedBlocks.begin() || Ret == (*it)->Start)
Ret = (*it)->Start + (*it)->Samples;
else
break;
}
return FFMIN(Ret, Start + Samples);
}
FFAudio::FFAudio() {
CurrentSample = 0;
DecodingBuffer = new uint8_t[AVCODEC_MAX_AUDIO_FRAME_SIZE * 10];
}
FFAudio::~FFAudio() {
delete[] DecodingBuffer;
}
void FFLAVFAudio::Free(bool CloseCodec) {
if (CloseCodec)
avcodec_close(CodecContext);
if (FormatContext)
av_close_input_file(FormatContext);
}
FFLAVFAudio::FFLAVFAudio(const char *SourceFile, int Track, FFIndex *Index, char *ErrorMsg, unsigned MsgSize) {
FormatContext = NULL;
AVCodec *Codec = NULL;
AudioTrack = Track;
Frames = (*Index)[AudioTrack];
if (Frames.size() == 0) {
Free(false);
_snprintf(ErrorMsg, MsgSize, "Audio track contains no frames, was it indexed properly?");
throw ErrorMsg;
}
if (av_open_input_file(&FormatContext, SourceFile, NULL, 0, NULL) != 0) {
_snprintf(ErrorMsg, MsgSize, "Couldn't open '%s'", SourceFile);
throw ErrorMsg;
}
if (av_find_stream_info(FormatContext) < 0) {
Free(false);
_snprintf(ErrorMsg, MsgSize, "Couldn't find stream information");
throw ErrorMsg;
}
CodecContext = FormatContext->streams[AudioTrack]->codec;
Codec = avcodec_find_decoder(CodecContext->codec_id);
if (Codec == NULL) {
Free(false);
_snprintf(ErrorMsg, MsgSize, "Audio codec not found");
throw ErrorMsg;
}
if (avcodec_open(CodecContext, Codec) < 0) {
Free(false);
_snprintf(ErrorMsg, MsgSize, "Could not open audio codec");
throw ErrorMsg;
}
// Always try to decode a frame to make sure all required parameters are known
int64_t Dummy;
if (DecodeNextAudioBlock(&Dummy, ErrorMsg, MsgSize) < 0) {
Free(true);
throw ErrorMsg;
}
if (av_seek_frame(FormatContext, AudioTrack, Frames[0].DTS, AVSEEK_FLAG_BACKWARD) < 0)
av_seek_frame(FormatContext, AudioTrack, Frames[0].DTS, AVSEEK_FLAG_BACKWARD | AVSEEK_FLAG_ANY);
avcodec_flush_buffers(CodecContext);
FillAP(AP, CodecContext, Frames);
if (AP.SampleRate <= 0 || AP.BitsPerSample <= 0) {
Free(true);
_snprintf(ErrorMsg, MsgSize, "Codec returned zero size audio");
throw ErrorMsg;
}
AudioCache.Initialize((AP.Channels * AP.BitsPerSample) / 8, 50);
}
int FFLAVFAudio::DecodeNextAudioBlock(int64_t *Count, char *ErrorMsg, unsigned MsgSize) {
const size_t SizeConst = (av_get_bits_per_sample_format(CodecContext->sample_fmt) * CodecContext->channels) / 8;
int Ret = -1;
*Count = 0;
uint8_t *Buf = DecodingBuffer;
AVPacket Packet, TempPacket;
InitNullPacket(&Packet);
InitNullPacket(&TempPacket);
while (av_read_frame(FormatContext, &Packet) >= 0) {
if (Packet.stream_index == AudioTrack) {
TempPacket.data = Packet.data;
TempPacket.size = Packet.size;
while (TempPacket.size > 0) {
int TempOutputBufSize = AVCODEC_MAX_AUDIO_FRAME_SIZE * 10;
Ret = avcodec_decode_audio3(CodecContext, (int16_t *)Buf, &TempOutputBufSize, &TempPacket);
if (Ret < 0) {// throw error or something?
av_free_packet(&Packet);
goto Done;
}
if (Ret > 0) {
TempPacket.size -= Ret;
TempPacket.data += Ret;
Buf += TempOutputBufSize;
if (SizeConst)
*Count += TempOutputBufSize / SizeConst;
}
}
av_free_packet(&Packet);
goto Done;
}
av_free_packet(&Packet);
}
Done:
return Ret;
}
int FFLAVFAudio::GetAudio(void *Buf, int64_t Start, int64_t Count, char *ErrorMsg, unsigned MsgSize) {
const int64_t SizeConst = (av_get_bits_per_sample_format(CodecContext->sample_fmt) * CodecContext->channels) / 8;
memset(Buf, 0, SizeConst * Count);
int PreDecBlocks = 0;
uint8_t *DstBuf = static_cast<uint8_t *>(Buf);
// Fill with everything in the cache
int64_t CacheEnd = AudioCache.FillRequest(Start, Count, DstBuf);
// Was everything in the cache?
if (CacheEnd == Start + Count)
return 0;
size_t CurrentAudioBlock;
// Is seeking required to decode the requested samples?
// if (!(CurrentSample >= Start && CurrentSample <= CacheEnd)) {
if (CurrentSample != CacheEnd) {
PreDecBlocks = 15;
CurrentAudioBlock = FFMAX((int64_t)Frames.FindClosestAudioKeyFrame(CacheEnd) - PreDecBlocks - 20, (int64_t)0);
// Did the seeking fail?
if (av_seek_frame(FormatContext, AudioTrack, Frames[CurrentAudioBlock].DTS, AVSEEK_FLAG_BACKWARD) < 0)
av_seek_frame(FormatContext, AudioTrack, Frames[CurrentAudioBlock].DTS, AVSEEK_FLAG_BACKWARD | AVSEEK_FLAG_ANY);
avcodec_flush_buffers(CodecContext);
AVPacket Packet;
InitNullPacket(&Packet);
// Establish where we actually are
// Trigger on packet dts difference since groups can otherwise be indistinguishable
int64_t LastDTS = - 1;
while (av_read_frame(FormatContext, &Packet) >= 0) {
if (Packet.stream_index == AudioTrack) {
if (LastDTS < 0) {
LastDTS = Packet.dts;
} else if (LastDTS != Packet.dts) {
for (size_t i = 0; i < Frames.size(); i++)
if (Frames[i].DTS == Packet.dts) {
// The current match was consumed
CurrentAudioBlock = i + 1;
break;
}
av_free_packet(&Packet);
break;
}
}
av_free_packet(&Packet);
}
} else {
CurrentAudioBlock = Frames.FindClosestAudioKeyFrame(CurrentSample);
}
int64_t DecodeCount;
do {
int Ret = DecodeNextAudioBlock(&DecodeCount, ErrorMsg, MsgSize);
if (Ret < 0) {
// FIXME
//Env->ThrowError("Bleh, bad audio decoding");
}
// Cache the block if enough blocks before it have been decoded to avoid garbage
if (PreDecBlocks == 0) {
AudioCache.CacheBlock(Frames[CurrentAudioBlock].SampleStart, DecodeCount, DecodingBuffer);
CacheEnd = AudioCache.FillRequest(CacheEnd, Start + Count - CacheEnd, DstBuf + (CacheEnd - Start) * SizeConst);
} else {
PreDecBlocks--;
}
CurrentAudioBlock++;
if (CurrentAudioBlock < Frames.size())
CurrentSample = Frames[CurrentAudioBlock].SampleStart;
} while (Start + Count - CacheEnd > 0 && CurrentAudioBlock < Frames.size());
return 0;
}
FFLAVFAudio::~FFLAVFAudio() {
Free(true);
}
void FFMatroskaAudio::Free(bool CloseCodec) {
if (CS)
cs_Destroy(CS);
if (MC.ST.fp) {
mkv_Close(MF);
fclose(MC.ST.fp);
}
if (CloseCodec)
avcodec_close(CodecContext);
av_free(CodecContext);
}
FFMatroskaAudio::FFMatroskaAudio(const char *SourceFile, int Track, FFIndex *Index, char *ErrorMsg, unsigned MsgSize) {
CodecContext = NULL;
AVCodec *Codec = NULL;
TrackInfo *TI = NULL;
CS = NULL;
Frames = (*Index)[Track];
if (Frames.size() == 0) {
Free(false);
_snprintf(ErrorMsg, MsgSize, "Audio track contains no frames, was it indexed properly?");
throw ErrorMsg;
}
MC.ST.fp = fopen(SourceFile, "rb");
if (MC.ST.fp == NULL) {
_snprintf(ErrorMsg, MsgSize, "Can't open '%s': %s", SourceFile, strerror(errno));
throw ErrorMsg;
}
setvbuf(MC.ST.fp, NULL, _IOFBF, CACHESIZE);
MF = mkv_OpenEx(&MC.ST.base, 0, 0, ErrorMessage, sizeof(ErrorMessage));
if (MF == NULL) {
fclose(MC.ST.fp);
_snprintf(ErrorMsg, MsgSize, "Can't parse Matroska file: %s", ErrorMessage);
throw ErrorMsg;
}
mkv_SetTrackMask(MF, ~(1 << Track));
TI = mkv_GetTrackInfo(MF, Track);
if (TI->CompEnabled) {
CS = cs_Create(MF, Track, ErrorMessage, sizeof(ErrorMessage));
if (CS == NULL) {
Free(false);
_snprintf(ErrorMsg, MsgSize, "Can't create decompressor: %s", ErrorMessage);
throw ErrorMsg;
}
}
CodecContext = avcodec_alloc_context();
CodecContext->extradata = (uint8_t *)TI->CodecPrivate;
CodecContext->extradata_size = TI->CodecPrivateSize;
Codec = avcodec_find_decoder(MatroskaToFFCodecID(TI->CodecID, TI->CodecPrivate));
if (Codec == NULL) {
Free(false);
_snprintf(ErrorMsg, MsgSize, "Video codec not found");
throw ErrorMsg;
}
if (avcodec_open(CodecContext, Codec) < 0) {
Free(false);
_snprintf(ErrorMsg, MsgSize, "Could not open video codec");
throw ErrorMsg;
}
// Always try to decode a frame to make sure all required parameters are known
int64_t Dummy;
if (DecodeNextAudioBlock(&Dummy, 0, ErrorMsg, MsgSize) < 0) {
Free(true);
throw ErrorMsg;
}
avcodec_flush_buffers(CodecContext);
FillAP(AP, CodecContext, Frames);
if (AP.SampleRate <= 0 || AP.BitsPerSample <= 0) {
Free(true);
_snprintf(ErrorMsg, MsgSize, "Codec returned zero size audio");
throw ErrorMsg;
}
AudioCache.Initialize((AP.Channels * AP.BitsPerSample) / 8, 50);
}
FFMatroskaAudio::~FFMatroskaAudio() {
Free(true);
}
int FFMatroskaAudio::GetAudio(void *Buf, int64_t Start, int64_t Count, char *ErrorMsg, unsigned MsgSize) {
const int64_t SizeConst = (av_get_bits_per_sample_format(CodecContext->sample_fmt) * CodecContext->channels) / 8;
memset(Buf, 0, SizeConst * Count);
int PreDecBlocks = 0;
uint8_t *DstBuf = static_cast<uint8_t *>(Buf);
// Fill with everything in the cache
int64_t CacheEnd = AudioCache.FillRequest(Start, Count, DstBuf);
// Was everything in the cache?
if (CacheEnd == Start + Count)
return 0;
int CurrentAudioBlock;
// Is seeking required to decode the requested samples?
// if (!(CurrentSample >= Start && CurrentSample <= CacheEnd)) {
if (CurrentSample != CacheEnd) {
PreDecBlocks = 15;
CurrentAudioBlock = FFMAX((int64_t)Frames.FindClosestAudioKeyFrame(CacheEnd) - PreDecBlocks, (int64_t)0);
avcodec_flush_buffers(CodecContext);
} else {
CurrentAudioBlock = Frames.FindClosestAudioKeyFrame(CurrentSample);
}
int64_t DecodeCount;
do {
int Ret = DecodeNextAudioBlock(&DecodeCount, CurrentAudioBlock, ErrorMsg, MsgSize);
if (Ret < 0) {
// FIXME
//Env->ThrowError("Bleh, bad audio decoding");
}
// Cache the block if enough blocks before it have been decoded to avoid garbage
if (PreDecBlocks == 0) {
AudioCache.CacheBlock(Frames[CurrentAudioBlock].SampleStart, DecodeCount, DecodingBuffer);
CacheEnd = AudioCache.FillRequest(CacheEnd, Start + Count - CacheEnd, DstBuf + (CacheEnd - Start) * SizeConst);
} else {
PreDecBlocks--;
}
CurrentAudioBlock++;
if (CurrentAudioBlock < static_cast<int>(Frames.size()))
CurrentSample = Frames[CurrentAudioBlock].SampleStart;
} while (Start + Count - CacheEnd > 0 && CurrentAudioBlock < static_cast<int>(Frames.size()));
return 0;
}
int FFMatroskaAudio::DecodeNextAudioBlock(int64_t *Count, int AudioBlock, char *ErrorMsg, unsigned MsgSize) {
const size_t SizeConst = (av_get_bits_per_sample_format(CodecContext->sample_fmt) * CodecContext->channels) / 8;
int Ret = -1;
*Count = 0;
uint8_t *Buf = DecodingBuffer;
AVPacket TempPacket;
InitNullPacket(&TempPacket);
unsigned int FrameSize = Frames[AudioBlock].FrameSize;
if (ReadFrame(Frames[AudioBlock].FilePos, FrameSize, CS, MC, ErrorMsg, MsgSize))
return 1;
TempPacket.data = MC.Buffer;
TempPacket.size = FrameSize;
if (Frames[AudioBlock].KeyFrame)
TempPacket.flags = AV_PKT_FLAG_KEY;
else
TempPacket.flags = 0;
while (TempPacket.size > 0) {
int TempOutputBufSize = AVCODEC_MAX_AUDIO_FRAME_SIZE;
Ret = avcodec_decode_audio3(CodecContext, (int16_t *)Buf, &TempOutputBufSize, &TempPacket);
if (Ret < 0) // throw error or something?
goto Done;
if (Ret > 0) {
TempPacket.size -= Ret;
TempPacket.data += Ret;
Buf += TempOutputBufSize;
if (SizeConst)
*Count += TempOutputBufSize / SizeConst;
}
}
Done:
return 0;
}
#ifdef HAALISOURCE
void FFHaaliAudio::Free(bool CloseCodec) {
if (CloseCodec)
avcodec_close(CodecContext);
av_free(CodecContext);
delete[] CodecPrivate;
}
int FFHaaliAudio::DecodeNextAudioBlock(int64_t *AFirstStartTime, int64_t *Count, char *ErrorMsg, unsigned MsgSize) {
const size_t SizeConst = (av_get_bits_per_sample_format(CodecContext->sample_fmt) * CodecContext->channels) / 8;
int Ret = -1;
*AFirstStartTime = -1;
*Count = 0;
uint8_t *Buf = DecodingBuffer;
AVPacket Packet;
InitNullPacket(&Packet);
for (;;) {
CComPtr<IMMFrame> pMMF;
if (pMMC->ReadFrame(NULL, &pMMF) != S_OK)
break;
REFERENCE_TIME Ts, Te;
if (*AFirstStartTime < 0 && SUCCEEDED(pMMF->GetTime(&Ts, &Te)))
*AFirstStartTime = Ts;
if (pMMF->GetTrack() == AudioTrack) {
BYTE *Data = NULL;
if (FAILED(pMMF->GetPointer(&Data)))
goto Done;
Packet.data = Data;
Packet.size = pMMF->GetActualDataLength();
if (pMMF->IsSyncPoint() == S_OK)
Packet.flags = AV_PKT_FLAG_KEY;
else
Packet.flags = 0;
while (Packet.size > 0) {
int TempOutputBufSize = AVCODEC_MAX_AUDIO_FRAME_SIZE * 10;
Ret = avcodec_decode_audio3(CodecContext, (int16_t *)Buf, &TempOutputBufSize, &Packet);
if (Ret < 0) {// throw error or something?
goto Done;
}
if (Ret > 0) {
Packet.size -= Ret;
Packet.data += Ret;
Buf += TempOutputBufSize;
if (SizeConst)
*Count += TempOutputBufSize / SizeConst;
}
}
goto Done;
}
}
Done:
return Ret;
}
FFHaaliAudio::FFHaaliAudio(const char *SourceFile, int Track, FFIndex *Index, int SourceMode, char *ErrorMsg, unsigned MsgSize) {
CodecPrivate = NULL;
AVCodec *Codec = NULL;
CodecContext = NULL;
AudioTrack = Track;
Frames = (*Index)[AudioTrack];
if (Frames.size() == 0) {
_snprintf(ErrorMsg, MsgSize, "Audio track contains no frames, was it indexed properly?");
throw ErrorMsg;
}
CLSID clsid = HAALI_TS_Parser;
if (SourceMode == 1)
clsid = HAALI_OGM_Parser;
if (FAILED(pMMC.CoCreateInstance(clsid))) {
_snprintf(ErrorMsg, MsgSize, "Can't create parser");
throw ErrorMsg;
}
CComPtr<IMemAlloc> pMA;
if (FAILED(pMA.CoCreateInstance(CLSID_MemAlloc))) {
_snprintf(ErrorMsg, MsgSize, "Can't create memory allocator");
throw ErrorMsg;
}
CComPtr<IMMStream> pMS;
if (FAILED(pMS.CoCreateInstance(CLSID_DiskFile))) {
_snprintf(ErrorMsg, MsgSize, "Can't create disk file reader");
throw ErrorMsg;
}
WCHAR WSourceFile[2048];
mbstowcs(WSourceFile, SourceFile, 2000);
CComQIPtr<IMMStreamOpen> pMSO(pMS);
if (FAILED(pMSO->Open(WSourceFile))) {
_snprintf(ErrorMsg, MsgSize, "Can't open file");
throw ErrorMsg;
}
if (FAILED(pMMC->Open(pMS, 0, NULL, pMA))) {
_snprintf(ErrorMsg, MsgSize, "Can't parse file");
throw ErrorMsg;
}
int CodecPrivateSize = 0;
int CurrentTrack = 0;
CComPtr<IEnumUnknown> pEU;
CComQIPtr<IPropertyBag> pBag;
if (SUCCEEDED(pMMC->EnumTracks(&pEU))) {
CComPtr<IUnknown> pU;
while (pEU->Next(1, &pU, NULL) == S_OK) {
if (CurrentTrack++ == Track) {
pBag = pU;
if (pBag) {
CComVariant pV;
pV.Clear();
if (SUCCEEDED(pBag->Read(L"CodecPrivate", &pV, NULL))) {
CodecPrivateSize = vtSize(pV);
CodecPrivate = new uint8_t[CodecPrivateSize];
vtCopy(pV, CodecPrivate);
}
pV.Clear();
if (SUCCEEDED(pBag->Read(L"CodecID", &pV, NULL)) && SUCCEEDED(pV.ChangeType(VT_BSTR))) {
char ACodecID[2048];
wcstombs(ACodecID, pV.bstrVal, 2000);
Codec = avcodec_find_decoder(MatroskaToFFCodecID(ACodecID, CodecPrivate));
}
}
}
pU = NULL;
}
}
CodecContext = avcodec_alloc_context();
CodecContext->extradata = CodecPrivate;
CodecContext->extradata_size = CodecPrivateSize;
if (Codec == NULL) {
Free(false);
_snprintf(ErrorMsg, MsgSize, "Audio codec not found");
throw ErrorMsg;
}
if (avcodec_open(CodecContext, Codec) < 0) {
Free(false);
_snprintf(ErrorMsg, MsgSize, "Could not open audio codec");
throw ErrorMsg;
}
// Always try to decode a frame to make sure all required parameters are known
int64_t Dummy1, Dummy2;
if (DecodeNextAudioBlock(&Dummy1, &Dummy2, ErrorMsg, MsgSize) < 0) {
Free(true);
throw ErrorMsg;
}
pMMC->Seek(Frames[0].DTS, MKVF_SEEK_TO_PREV_KEYFRAME_STRICT);
avcodec_flush_buffers(CodecContext);
FillAP(AP, CodecContext, Frames);
if (AP.SampleRate <= 0 || AP.BitsPerSample <= 0) {
Free(true);
_snprintf(ErrorMsg, MsgSize, "Codec returned zero size audio");
throw ErrorMsg;
}
AudioCache.Initialize((AP.Channels * AP.BitsPerSample) / 8, 50);
}
FFHaaliAudio::~FFHaaliAudio() {
Free(true);
}
int FFHaaliAudio::GetAudio(void *Buf, int64_t Start, int64_t Count, char *ErrorMsg, unsigned MsgSize) {
const int64_t SizeConst = (av_get_bits_per_sample_format(CodecContext->sample_fmt) * CodecContext->channels) / 8;
memset(Buf, 0, SizeConst * Count);
bool HasSeeked = false;
int PreDecBlocks = 0;
uint8_t *DstBuf = static_cast<uint8_t *>(Buf);
// Fill with everything in the cache
int64_t CacheEnd = AudioCache.FillRequest(Start, Count, DstBuf);
// Was everything in the cache?
if (CacheEnd == Start + Count)
return 0;
int CurrentAudioBlock;
// Is seeking required to decode the requested samples?
// if (!(CurrentSample >= Start && CurrentSample <= CacheEnd)) {
if (CurrentSample != CacheEnd) {
PreDecBlocks = 15;
CurrentAudioBlock = FFMAX((int64_t)Frames.FindClosestAudioKeyFrame(CacheEnd) - PreDecBlocks - 20, (int64_t)0);
pMMC->Seek(Frames[CurrentAudioBlock].DTS, MKVF_SEEK_TO_PREV_KEYFRAME_STRICT);
avcodec_flush_buffers(CodecContext);
HasSeeked = true;
} else {
CurrentAudioBlock = Frames.FindClosestAudioKeyFrame(CurrentSample);
}
int64_t FirstTime, DecodeCount;
do {
int Ret = DecodeNextAudioBlock(&FirstTime, &DecodeCount, ErrorMsg, MsgSize);
if (Ret < 0) {
// FIXME
//Env->ThrowError("Bleh, bad audio decoding");
}
if (HasSeeked) {
CurrentAudioBlock = Frames.ClosestFrameFromDTS(FirstTime);
HasSeeked = false;
}
// Cache the block if enough blocks before it have been decoded to avoid garbage
if (PreDecBlocks == 0) {
AudioCache.CacheBlock(Frames[CurrentAudioBlock].SampleStart, DecodeCount, DecodingBuffer);
CacheEnd = AudioCache.FillRequest(CacheEnd, Start + Count - CacheEnd, DstBuf + (CacheEnd - Start) * SizeConst);
} else {
PreDecBlocks--;
}
CurrentAudioBlock++;
if (CurrentAudioBlock < static_cast<int>(Frames.size()))
CurrentSample = Frames[CurrentAudioBlock].SampleStart;
} while (Start + Count - CacheEnd > 0 && CurrentAudioBlock < static_cast<int>(Frames.size()));
return 0;
}
#endif // HAALISOURCE

175
aegisub/libffms/ffavisynth.cpp
View file

@ -1,175 +0,0 @@
// Copyright (c) 2007-2009 Fredrik Mellbin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include "ffavisynth.h"
#include <cmath>
AvisynthVideoSource::AvisynthVideoSource(const char *SourceFile, int Track, FFIndex *Index, int FPSNum, int FPSDen, const char *PP, int Threads, int SeekMode, IScriptEnvironment* Env, char *ErrorMsg, unsigned MsgSize) {
memset(&VI, 0, sizeof(VI));
this->FPSNum = FPSNum;
this->FPSDen = FPSDen;
V = FFMS_CreateVideoSource(SourceFile, Track, Index, PP, Threads, SeekMode, ErrorMsg, MsgSize);
if (!V)
Env->ThrowError(ErrorMsg);
try {
InitOutputFormat(Env);
} catch (AvisynthError &) {
FFMS_DestroyVideoSource(V);
throw;
}
const TVideoProperties *VP = FFMS_GetVideoProperties(V);
if (FPSNum > 0 && FPSDen > 0) {
VI.fps_denominator = FPSDen;
VI.fps_numerator = FPSNum;
VI.num_frames = static_cast<int>(ceil(((VP->LastTime - VP->FirstTime) * FPSNum) / FPSDen));
} else {
VI.fps_denominator = VP->FPSDenominator;
VI.fps_numerator = VP->FPSNumerator;
VI.num_frames = VP->NumFrames;
}
// Set AR variables
Env->SetVar("FFSAR_NUM", VP->SARNum);
Env->SetVar("FFSAR_DEN", VP->SARDen);
if (VP->SARNum > 0 && VP->SARDen > 0)
Env->SetVar("FFSAR", VP->SARNum / (double)VP->SARDen);
// Set crop variables
Env->SetVar("FFCROP_LEFT", VP->CropLeft);
Env->SetVar("FFCROP_RIGHT", VP->CropRight);
Env->SetVar("FFCROP_TOP", VP->CropTop);
Env->SetVar("FFCROP_BOTTOM", VP->CropBottom);
}
AvisynthVideoSource::~AvisynthVideoSource() {
FFMS_DestroyVideoSource(V);
}
void AvisynthVideoSource::InitOutputFormat(IScriptEnvironment *Env) {
const TVideoProperties *VP = FFMS_GetVideoProperties(V);
if (FFMS_SetOutputFormat(V, (1 << FFMS_GetPixFmt("yuvj420p")) |
(1 << FFMS_GetPixFmt("yuv420p")) | (1 << FFMS_GetPixFmt("yuyv422")) |
(1 << FFMS_GetPixFmt("rgb32")) | (1 << FFMS_GetPixFmt("bgr24")),
VP->Width, VP->Height, NULL, 0))
Env->ThrowError("FFVideoSource: No suitable output format found");
VP = FFMS_GetVideoProperties(V);
if (VP->VPixelFormat == FFMS_GetPixFmt("yuvj420p") || VP->VPixelFormat == FFMS_GetPixFmt("yuv420p"))
VI.pixel_type = VideoInfo::CS_I420;
else if (VP->VPixelFormat == FFMS_GetPixFmt("yuyv422"))
VI.pixel_type = VideoInfo::CS_YUY2;
else if (VP->VPixelFormat == FFMS_GetPixFmt("rgb32"))
VI.pixel_type = VideoInfo::CS_BGR32;
else if (VP->VPixelFormat == FFMS_GetPixFmt("bgr24"))
VI.pixel_type = VideoInfo::CS_BGR24;
else
Env->ThrowError("FFVideoSource: No suitable output format found");
VI.image_type = VideoInfo::IT_TFF;
VI.width = VP->Width;
VI.height = VP->Height;
// Crop to obey avisynth's even width/height requirements
if (VI.pixel_type == VideoInfo::CS_I420) {
VI.height -= VI.height & 1;
VI.width -= VI.width & 1;
}
if (VI.pixel_type == VideoInfo::CS_YUY2) {
VI.width -= VI.width & 1;
}
}
PVideoFrame AvisynthVideoSource::OutputFrame(const TAVFrameLite *Frame, IScriptEnvironment *Env) {
TAVFrameLite *SrcPicture = const_cast<TAVFrameLite *>(Frame);
PVideoFrame Dst = Env->NewVideoFrame(VI);
if (VI.pixel_type == VideoInfo::CS_I420) {
Env->BitBlt(Dst->GetWritePtr(PLANAR_Y), Dst->GetPitch(PLANAR_Y), SrcPicture->Data[0], SrcPicture->Linesize[0], Dst->GetRowSize(PLANAR_Y), Dst->GetHeight(PLANAR_Y));
Env->BitBlt(Dst->GetWritePtr(PLANAR_U), Dst->GetPitch(PLANAR_U), SrcPicture->Data[1], SrcPicture->Linesize[1], Dst->GetRowSize(PLANAR_U), Dst->GetHeight(PLANAR_U));
Env->BitBlt(Dst->GetWritePtr(PLANAR_V), Dst->GetPitch(PLANAR_V), SrcPicture->Data[2], SrcPicture->Linesize[2], Dst->GetRowSize(PLANAR_V), Dst->GetHeight(PLANAR_V));
} else if (VI.IsRGB()) {
Env->BitBlt(Dst->GetWritePtr() + Dst->GetPitch() * (Dst->GetHeight() - 1), -Dst->GetPitch(), SrcPicture->Data[0], SrcPicture->Linesize[0], Dst->GetRowSize(), Dst->GetHeight());
} else { // YUY2
Env->BitBlt(Dst->GetWritePtr(), Dst->GetPitch(), SrcPicture->Data[0], SrcPicture->Linesize[0], Dst->GetRowSize(), Dst->GetHeight());
}
return Dst;
}
PVideoFrame AvisynthVideoSource::GetFrame(int n, IScriptEnvironment *Env) {
char ErrorMsg[1024];
unsigned MsgSize = sizeof(ErrorMsg);
const TAVFrameLite *Frame;
if (FPSNum > 0 && FPSDen > 0)
Frame = FFMS_GetFrameByTime(V, FFMS_GetVideoProperties(V)->FirstTime + (double)(n * (int64_t)FPSDen) / FPSNum, ErrorMsg, MsgSize);
else
Frame = FFMS_GetFrame(V, n, ErrorMsg, MsgSize);
if (Frame == NULL)
Env->ThrowError("FFVideoSource: %s", ErrorMsg);
Env->SetVar("FFPICT_TYPE", Frame->PictType);
return OutputFrame(Frame, Env);
}
AvisynthAudioSource::AvisynthAudioSource(const char *SourceFile, int Track, FFIndex *Index, IScriptEnvironment* Env, char *ErrorMsg, unsigned MsgSize) {
memset(&VI, 0, sizeof(VI));
A = FFMS_CreateAudioSource(SourceFile, Track, Index, ErrorMsg, MsgSize);
if (!A)
Env->ThrowError(ErrorMsg);
const TAudioProperties AP = *FFMS_GetAudioProperties(A);
VI.nchannels = AP.Channels;
VI.num_audio_samples = AP.NumSamples;
VI.audio_samples_per_second = AP.SampleRate;
if (AP.Float && AP.BitsPerSample == 32) {
VI.sample_type = SAMPLE_FLOAT;
} else {
switch (AP.BitsPerSample) {
case 8: VI.sample_type = SAMPLE_INT8; break;
case 16: VI.sample_type = SAMPLE_INT16; break;
case 24: VI.sample_type = SAMPLE_INT24; break;
case 32: VI.sample_type = SAMPLE_INT32; break;
default: Env->ThrowError("FFAudioSource: Bad audio format");
}
}
}
AvisynthAudioSource::~AvisynthAudioSource() {
FFMS_DestroyAudioSource(A);
}
void AvisynthAudioSource::GetAudio(void* Buf, __int64 Start, __int64 Count, IScriptEnvironment *Env) {
char ErrorMsg[1024];
unsigned MsgSize = sizeof(ErrorMsg);
if (FFMS_GetAudio(A, Buf, Start, Count, ErrorMsg, MsgSize))
Env->ThrowError(ErrorMsg);
}

61
aegisub/libffms/ffavisynth.h
View file

@ -1,61 +0,0 @@
// Copyright (c) 2007-2009 Fredrik Mellbin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#ifndef FFAVISYNTH_H
#define FFAVISYNTH_H
#include <windows.h>
#include "avisynth.h"
#include "ffms.h"
class AvisynthVideoSource : public IClip {
private:
VideoInfo VI;
FFVideo *V;
int FPSNum;
int FPSDen;
void InitOutputFormat(IScriptEnvironment *Env);
PVideoFrame OutputFrame(const TAVFrameLite *SrcPicture, IScriptEnvironment *Env);
public:
AvisynthVideoSource(const char *SourceFile, int Track, FFIndex *Index, int FPSNum, int FPSDen, const char *PP, int Threads, int SeekMode, IScriptEnvironment* Env, char *ErrorMsg, unsigned MsgSize);
~AvisynthVideoSource();
bool __stdcall GetParity(int n) { return false; }
void __stdcall SetCacheHints(int cachehints, int frame_range) { }
const VideoInfo& __stdcall GetVideoInfo() { return VI; }
void __stdcall GetAudio(void* Buf, __int64 Start, __int64 Count, IScriptEnvironment *Env) { }
PVideoFrame __stdcall GetFrame(int n, IScriptEnvironment *Env);
};
class AvisynthAudioSource : public IClip {
private:
VideoInfo VI;
FFAudio *A;
public:
AvisynthAudioSource(const char *SourceFile, int Track, FFIndex *Index, IScriptEnvironment* Env, char *ErrorMsg, unsigned MsgSize);
~AvisynthAudioSource();
bool __stdcall GetParity(int n) { return false; }
void __stdcall SetCacheHints(int cachehints, int frame_range) { }
const VideoInfo& __stdcall GetVideoInfo() { return VI; }
void __stdcall GetAudio(void* Buf, __int64 Start, __int64 Count, IScriptEnvironment *Env);
PVideoFrame __stdcall GetFrame(int n, IScriptEnvironment *Env) { return NULL; };
};
#endif

262
aegisub/libffms/ffavsfilters.cpp
View file

@ -1,262 +0,0 @@
// Copyright (c) 2007-2009 Fredrik Mellbin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include <string>
#include "ffms.h"
#include "ffavisynth.h"
#include "ffswscale.h"
#include "ffpp.h"
static int GetNumberOfLogicalCPUs() {
SYSTEM_INFO SI;
GetSystemInfo(&SI);
return SI.dwNumberOfProcessors;
}
static AVSValue __cdecl CreateFFIndex(AVSValue Args, void* UserData, IScriptEnvironment* Env) {
FFMS_Init();
char ErrorMsg[1024];
unsigned MsgSize = sizeof(ErrorMsg);
if (!Args[0].Defined())
Env->ThrowError("FFIndex: No source specified");
const char *Source = Args[0].AsString();
const char *CacheFile = Args[1].AsString("");
int IndexMask = Args[2].AsInt(-1);
int DumpMask = Args[3].AsInt(0);
const char *AudioFile = Args[4].AsString("");
bool OverWrite = Args[5].AsBool(false);
std::string DefaultCache(Source);
DefaultCache.append(".ffindex");
if (!strcmp(CacheFile, ""))
CacheFile = DefaultCache.c_str();
if (!strcmp(AudioFile, ""))
AudioFile = Source;
// Return values
// 0: Index already present
// 1: Index generated
// 2: Index forced to be overwritten
FFIndex *Index = NULL;
if (OverWrite || !(Index = FFMS_ReadIndex(CacheFile, ErrorMsg, MsgSize))) {
if (!(Index = FFMS_MakeIndex(Source, IndexMask, DumpMask, FFMS_DefaultAudioFilename, NULL, true, NULL, NULL, ErrorMsg, MsgSize)))
Env->ThrowError("FFIndex: %s", ErrorMsg);
if (FFMS_WriteIndex(CacheFile, Index, ErrorMsg, MsgSize)) {
FFMS_DestroyIndex(Index);
Env->ThrowError("FFIndex: %s", ErrorMsg);
}
FFMS_DestroyIndex(Index);
if (!OverWrite)
return AVSValue(1);
else
return AVSValue(2);
} else {
FFMS_DestroyIndex(Index);
return AVSValue(0);
}
}
static AVSValue __cdecl CreateFFVideoSource(AVSValue Args, void* UserData, IScriptEnvironment* Env) {
FFMS_Init();
char ErrorMsg[1024];
unsigned MsgSize = sizeof(ErrorMsg);
if (!Args[0].Defined())
Env->ThrowError("FFVideoSource: No source specified");
const char *Source = Args[0].AsString();
int Track = Args[1].AsInt(-1);
bool Cache = Args[2].AsBool(true);
const char *CacheFile = Args[3].AsString("");
int FPSNum = Args[4].AsInt(-1);
int FPSDen = Args[5].AsInt(1);
const char *PP = Args[6].AsString("");
int Threads = Args[7].AsInt(-1);
const char *Timecodes = Args[8].AsString("");
int SeekMode = Args[9].AsInt(1);
if (Track <= -2)
Env->ThrowError("FFVideoSource: No video track selected");
if (SeekMode < -1 || SeekMode > 3)
Env->ThrowError("FFVideoSource: Invalid seekmode selected");
if (Threads <= 0)
Threads = GetNumberOfLogicalCPUs();
if (Threads < 1)
Env->ThrowError("FFVideoSource: Invalid thread count");
if (!_stricmp(Source, Timecodes))
Env->ThrowError("FFVideoSource: Timecodes will overwrite the source");
std::string DefaultCache(Source);
DefaultCache.append(".ffindex");
if (!strcmp(CacheFile, ""))
CacheFile = DefaultCache.c_str();
FFIndex *Index = NULL;
if (Cache)
Index = FFMS_ReadIndex(CacheFile, ErrorMsg, MsgSize);
if (!Index) {
if (!(Index = FFMS_MakeIndex(Source, 0, 0, NULL, NULL, true, NULL, NULL, ErrorMsg, MsgSize)))
Env->ThrowError("FFVideoSource: %s", ErrorMsg);
if (Cache)
if (FFMS_WriteIndex(CacheFile, Index, ErrorMsg, MsgSize)) {
FFMS_DestroyIndex(Index);
Env->ThrowError("FFVideoSource: %s", ErrorMsg);
}
}
if (Track == -1)
Track = FFMS_GetFirstIndexedTrackOfType(Index, FFMS_TYPE_VIDEO, ErrorMsg, MsgSize);
if (Track < 0)
Env->ThrowError("FFVideoSource: No video track found");
if (strcmp(Timecodes, "")) {
if (FFMS_WriteTimecodes(FFMS_GetTrackFromIndex(Index, Track), Timecodes, ErrorMsg, MsgSize)) {
FFMS_DestroyIndex(Index);
Env->ThrowError("FFVideoSource: %s", ErrorMsg);
}
}
AvisynthVideoSource *Filter;
try {
Filter = new AvisynthVideoSource(Source, Track, Index, FPSNum, FPSDen, PP, Threads, SeekMode, Env, ErrorMsg, MsgSize);
} catch (...) {
FFMS_DestroyIndex(Index);
throw;
}
FFMS_DestroyIndex(Index);
return Filter;
}
static AVSValue __cdecl CreateFFAudioSource(AVSValue Args, void* UserData, IScriptEnvironment* Env) {
FFMS_Init();
char ErrorMsg[1024];
unsigned MsgSize = sizeof(ErrorMsg);
if (!Args[0].Defined())
Env->ThrowError("FFAudioSource: No source specified");
const char *Source = Args[0].AsString();
int Track = Args[1].AsInt(-1);
bool Cache = Args[2].AsBool(true);
const char *CacheFile = Args[3].AsString("");
if (Track <= -2)
Env->ThrowError("FFAudioSource: No audio track selected");
std::string DefaultCache(Source);
DefaultCache.append(".ffindex");
if (!strcmp(CacheFile, ""))
CacheFile = DefaultCache.c_str();
FFIndex *Index = NULL;
if (Cache)
Index = FFMS_ReadIndex(CacheFile, ErrorMsg, MsgSize);
// Index needs to be remade if it is an unindexed audio track
if (Index && Track >= 0 && Track < FFMS_GetNumTracks(Index)
&& FFMS_GetTrackType(FFMS_GetTrackFromIndex(Index, Track)) == FFMS_TYPE_AUDIO
&& FFMS_GetNumFrames(FFMS_GetTrackFromIndex(Index, Track)) == 0) {
FFMS_DestroyIndex(Index);
Index = NULL;
}
// More complicated for finding a default track, reindex the file if at least one audio track exists
if (Index && FFMS_GetFirstTrackOfType(Index, FFMS_TYPE_AUDIO, ErrorMsg, MsgSize) >= 0
&& FFMS_GetFirstIndexedTrackOfType(Index, FFMS_TYPE_AUDIO, ErrorMsg, MsgSize) < 0) {
for (int i = 0; i < FFMS_GetNumTracks(Index); i++) {
if (FFMS_GetTrackType(FFMS_GetTrackFromIndex(Index, i)) == FFMS_TYPE_AUDIO) {
FFMS_DestroyIndex(Index);
Index = NULL;
break;
}
}
}
if (!Index) {
if (!(Index = FFMS_MakeIndex(Source, -1, 0, NULL, NULL, true, NULL, NULL, ErrorMsg, MsgSize)))
Env->ThrowError("FFAudioSource: %s", ErrorMsg);
if (Cache)
if (FFMS_WriteIndex(CacheFile, Index, ErrorMsg, MsgSize)) {
FFMS_DestroyIndex(Index);
Env->ThrowError("FFAudioSource: %s", ErrorMsg);
}
}
if (Track == -1)
Track = FFMS_GetFirstIndexedTrackOfType(Index, FFMS_TYPE_AUDIO, ErrorMsg, MsgSize);
if (Track < 0)
Env->ThrowError("FFAudioSource: No audio track found");
AvisynthAudioSource *Filter;
try {
Filter = new AvisynthAudioSource(Source, Track, Index, Env, ErrorMsg, MsgSize);
} catch (...) {
FFMS_DestroyIndex(Index);
throw;
}
FFMS_DestroyIndex(Index);
return Filter;
}
static AVSValue __cdecl CreateFFPP(AVSValue Args, void* UserData, IScriptEnvironment* Env) {
return new FFPP(Args[0].AsClip(), Args[1].AsString(""), Env);
}
static AVSValue __cdecl CreateSWScale(AVSValue Args, void* UserData, IScriptEnvironment* Env) {
return new SWScale(Args[0].AsClip(), Args[1].AsInt(0), Args[2].AsInt(0), Args[3].AsString("BICUBIC"), Args[4].AsString(""), Env);
}
static AVSValue __cdecl FFGetLogLevel(AVSValue Args, void* UserData, IScriptEnvironment* Env) {
return FFMS_GetLogLevel();
}
static AVSValue __cdecl FFSetLogLevel(AVSValue Args, void* UserData, IScriptEnvironment* Env) {
FFMS_SetLogLevel(Args[0].AsInt());
return FFMS_GetLogLevel();
}
extern "C" __declspec(dllexport) const char* __stdcall AvisynthPluginInit2(IScriptEnvironment* Env) {
Env->AddFunction("FFIndex", "[source]s[cachefile]s[indexmask]i[dumpmask]i[audiofile]s[overwrite]b", CreateFFIndex, 0);
Env->AddFunction("FFVideoSource", "[source]s[track]i[cache]b[cachefile]s[fpsnum]i[fpsden]i[pp]s[threads]i[timecodes]s[seekmode]i", CreateFFVideoSource, 0);
Env->AddFunction("FFAudioSource", "[source]s[track]i[cache]b[cachefile]s", CreateFFAudioSource, 0);
Env->AddFunction("FFPP", "c[pp]s", CreateFFPP, 0);
Env->AddFunction("SWScale", "c[width]i[height]i[resizer]s[colorspace]s", CreateSWScale, 0);
Env->AddFunction("FFGetLogLevel", "", FFGetLogLevel, 0);
Env->AddFunction("FFSetLogLevel", "i", FFSetLogLevel, 0);
return "FFmpegSource - The Second Coming";
}

32
aegisub/libffms/ffms2.avsi
View file

@ -1,32 +0,0 @@
# FFmpegSource 1.21 syntax compatibility
# Created by TheFluff
function FFmpegSource2(string source, int "vtrack", int "atrack", bool "cache", \
string "cachefile", int "fpsnum", int "fpsden", string "pp", int "threads", \
string "timecodes", int "seekmode", bool "overwrite") {
vtrack = default(vtrack,-1)
atrack = default(atrack,-2)
cache = default(cache,true)
cachefile = default(cachefile,source+".ffindex")
fpsnum = default(fpsnum,-1)
fpsden = default(fpsden,1)
pp = default(pp,"")
threads = default(threads,-1)
timecodes = default(timecodes,"")
seekmode = default(seekmode,1)
overwrite = default(overwrite,false)
((cache == true) && (atrack <= -2)) ? ffindex(source=source, cachefile=cachefile, \
indexmask=0, overwrite=overwrite) : (cache == true) ? ffindex(source=source, \
cachefile=cachefile, indexmask=-1, overwrite=overwrite) : nop
v = ffvideosource(source=source, track=vtrack, cache=cache, cachefile=cachefile, \
fpsnum=fpsnum, fpsden=fpsden, pp=pp, threads=threads, timecodes=timecodes, \
seekmode=seekmode)
a = (atrack <= -2) ? blankclip(audio_rate=0) : ffaudiosource(source=source, \
track=atrack, cache=cache, cachefile=cachefile)
return audiodubex(v,a)
}

351
aegisub/libffms/ffms2.html
View file

@ -1,351 +0,0 @@
<html>
<head>
<title>
FFmpegSource2 Documentation
</title>
</head>
<body>
<h1>FFmpegSource2 Documentation</h1>
<p>
Opens files using ffmpeg and nothing else. May be frame accurate on good days. The source is MIT licensed and can be obtained from "http://svn.aegisub.net/trunk/aegisub/FFmpegSource2/". The precompiled binary is GPL licensed. If you are religious you may consider this the second coming.
</p>
<h2>Known issues</h2>
<ul>
<li>FFAudioSource() will have to remake any index implicitly created by FFVideoSource() and therefore code like
<pre>
AudioDub(FFVideoSource(X), FFAudioSource(X))
</pre>
will require two indexing passes. Apart from the time consumed this is harmless. To work around it open the audio first
<pre>
A = FFAudioSource(X)
V = FFVideoSource(X)
AudioDub(V, A)
</pre>
or use FFIndex().
<pre>
FFIndex(X)
AudioDub(FFVideoSource(X), FFAudioSource(X))
</pre>
</li>
<li>FFIndex() will silently ignore fatal decoding errors when indexing. This means that indexing a specific track may have failed even if FFIndex() succeeds.</li>
<li>Requires <a href='http://haali.cs.msu.ru/mkv/'>Haali's Media Splitter</a> if ogm or mpeg ps/ts is to be opened.</li>
<li>Avi files with NVOPs (sometimes occurs in xvid and such) will desync when these frames are encountered. Remux to mkv/mp4 before opening to solve it for now.</li>
<li>There are still some issues with FFAudioSource but it should be good enough for actual use in many cases now.</li>
</ul>
<h2>Compatibility - Video</h2>
<ul>
<li>AVI, MKV, MP4, FLV: Frame accurate</li>
<li>WMV: Frame accurate(?) but avformat seems to pick keyframes relatively far away</li>
<li>OGM: Frame accurate(?)</li>
<li>VOB: No rff flags applied</li>
<li>MPG: Seeking seems to be off by one or two frames now and then</li>
<li>M2TS, TS: Seeking seems to be off a few frames here and there</li>
<li>Image files: Most formats can be opened if seekmode=-1 is set, no animation support</li>
</ul>
<h2>Compatibility - Audio</h2>
<ul>
<li>All formats are written to separate wave64 files</li>
<li>No wave64 reader is provided</li>
</ul>
<h2>Usage</h2>
<p>
<b>FFIndex(string source, string cachefile = source + ".ffindex", int indexmask = -1, int dumpmask = 0, string audiofile = source, bool overwrite = false)</b><br />
Used to invoke indexing separately and to write audio tracks to disk as wave64 files
</p>
<p>
<b>FFVideoSource(string source, int track, bool cache = true, string cachefile = source + ".ffindex", int fpsnum = -1, int fpsden = 1, string pp, int threads = -1, string timecodes, int seekmode = 1)</b><br />
Opens video, will invoke indexing with the defaults if no preexisting index is found
</p>
<p>
<b>FFAudioSource(string source, int track, bool cache = true, string cachefile = source + ".ffindex")</b><br />
Opens audio, <b>if an index already exists it needs to contain a suitable audio index or empty audio will be returned</b>, will invoke indexing with the defaults if no preexisting index is found
</p>
<p>
<b>FFPP(clip, string pp)</b><br />
Separate postprocessing which also seems to include a few simple deinterlacers
</p>
<p>
<b>SWScale(clip, width = -1, height = -1, resizer = "BICUBIC", colorspace = "")</b><br />
Separate postprocessing which also seems to include a few simple deinterlacers
</p>
<b>FFSetLogLevel(int Level)</b><br />
Sets the log FFmpeg logging level, defaults to quiet (-8) and the FFmpeg default is 16, all different values can be found in avutil/log.h
</p>
<b>FFGetLogLevel()</b><br />
Returns the current level of logging as an int
</p>
<p>
<b>source:</b>
Source file.
</p>
<p>
<b>indexmask &amp; dumpmask:</b>
Which audio tracks to index/write to disk. Dumping a track also implies indexing since the same work has to be done anyway. It is a binary mask meaning that 7 corresponds to writing tracks 1-3. Non-audio tracks are ignored. -1 writes all tracks.
</p>
<p>
<b>audiofile:</b>
The base name to use for the decoded audio. Track number and delay is appended.
</p>
<p>
<b>overwrite:</b>
Forces reindexing even if a valid index already exists. May be useful for trackmask changes or testing.
</p>
<p>
<b>track:</b>
Track number as seen by the relevant demuxer, starts from 0, -1 means it will pick the first suitable track.
</p>
<p>
<b>fpsnum &amp; fpsden:</b>
For VFR -> CFR conversion. Setting fpsnum <= 0 means a 1:1 relation with the encoded frames.
</p>
<p>
<b>timecodes:</b>
File to output timecodes to, if the file exists it will be overwritten.
</p>
<p>
<b>cache:</b>
Write indexing information to a file for later use. This setting does not control if the video index is loaded which it always is if it exists.
</p>
<p>
<b>cachefile</b>
Where to write the cache information.
</p>
<p>
<b>pp:</b>
See the table below for a full description, an empty string means no processing. It is recommended to avoid the autoq option since it's currently unknown what effect it will have on the processing.
</p>
<p>
<b>threads:</b>
Sets the number of decoder threads used. Defaults to the number of cpus reported by windows. Ignored by lavc if the used decoder doesn't implement it.
</p>
<p>
<b>seekmode:</b>
Force how seeking is handled, has no effect on matroska files which always use the equivalent of seekmode=1<br />
<b>-1:</b> linear access without rewind, will throw an error if each successive requested frame number isn't bigger than the last one, only intended for opening images but might work on well with some obscure video format<br />
<b>0:</b> linear access, the definition of slow but should make some formats "usable"<br />
<b>1:</b> safe normal, bases seeking decisions on the reported keyframe positions<br />
<b>2:</b> unsafe normal, same as 1 but no error will be thrown if the exact destination has to be guessed<br />
<b>3:</b> aggressive, seek in the forward direction even if no closer keyframe is known to exist, only useful for testing and containers where avformat doesn't report keyframes properly
</p>
<p>
<b>width &amp; height:</b>
Width and height to resize to. Value below or equal to 0 is the same as specifying the input dimensions.
</p>
<p>
<b>resizer:</b>
Selects the resizer used for resampling the chroma planes and normal resizing. The available methods are: FAST_BILINEAR, BILINEAR, BICUBIC, X, POINT, AREA, BICUBLIN, GAUSS, SINC, LANCZOS and SPLINE.
</p>
<p>
<b>colorspace:</b>
The colorspace to convert to. The names are YV12, YUY2, RGB24, RGB32 and the empty string for same as input.
</p>
<h2>Exported Avisynth variables</h2>
<p>
<b>FFSAR_NUM, FFSAR_DEN, FFSAR:</b>
The playback aspect ratio specified by the container. FFSAR_NUM and FFSAR_DEN make up the rational number of the ratio and FFSAR is only provided for convenience.
</p>
<p>
<b>FFCROP_LEFT, FFCROP_RIGHT, FFCROP_TOP, FFCROP_BOTTOM:</b>
The on playback cropping specified by the container.
</p>
<p>
<b>FFPICT_TYPE:</b>
The picture type of the most recently requested frame. Use after_frame=true in Avisynth's conditional scripting for proper results. The FFmpeg source definition of the numbers:
<pre>
FF_I_TYPE 1 ///< Intra
FF_P_TYPE 2 ///< Predicted
FF_B_TYPE 3 ///< Bi-dir predicted
FF_S_TYPE 4 ///< S(GMC)-VOP MPEG4
FF_SI_TYPE 5 ///< Switching Intra
FF_SP_TYPE 6 ///< Switching Predicted
FF_BI_TYPE 7
</pre>
</p>
<h2>PP string format</h2>
<pre>
Available postprocessing filters:
Filters Options
short long name short long option Description
* * a autoq CPU power dependent enabler
c chrom chrominance filtering enabled
y nochrom chrominance filtering disabled
n noluma luma filtering disabled
hb hdeblock (2 threshold) horizontal deblocking filter
1. difference factor: default=32, higher -> more deblocking
2. flatness threshold: default=39, lower -> more deblocking
the h & v deblocking filters share these
so you can't set different thresholds for h / v
vb vdeblock (2 threshold) vertical deblocking filter
ha hadeblock (2 threshold) horizontal deblocking filter
va vadeblock (2 threshold) vertical deblocking filter
h1 x1hdeblock experimental h deblock filter 1
v1 x1vdeblock experimental v deblock filter 1
dr dering deringing filter
al autolevels automatic brightness / contrast
f fullyrange stretch luminance to (0..255)
lb linblenddeint linear blend deinterlacer
li linipoldeint linear interpolating deinterlace
ci cubicipoldeint cubic interpolating deinterlacer
md mediandeint median deinterlacer
fd ffmpegdeint ffmpeg deinterlacer
l5 lowpass5 FIR lowpass deinterlacer
de default hb:a,vb:a,dr:a
fa fast h1:a,v1:a,dr:a
ac ha:a:128:7,va:a,dr:a
tn tmpnoise (3 threshold) temporal noise reducer
1. <= 2. <= 3. larger -> stronger filtering
fq forceQuant <quantizer> force quantizer
Usage:
<filterName>[:<option>[:<option>...]][[,|/][-]<filterName>[:<option>...]]...
long form example:
vdeblock:autoq/hdeblock:autoq/linblenddeint default,-vdeblock
short form example:
vb:a/hb:a/lb de,-vb
more examples:
tn:64:128:256
</pre>
<h2>Compiling</h2>
<p><b>zlib</b> from http://www.zlib.net/</p>
<p><b>FFmpeg svn</b> from http://ffmpeg.mplayerhq.hu/</p>
<p><b>pthreads</b> only required for FFmpeg-mt compiles</p>
<p><b>Required FFmpeg Configuration:</b>
./configure --enable-memalign-hack --enable-gpl --enable-postproc
<p><b>Suggested Additional Options:</b>
--enable-w32threads --disable-encoders --disable-muxers --disable-network --disable-debug --enable-libfaad --disable-decoder=aac</p>
<p>
Note that --enable-w32threads or --enable-pthreads is required for multithreaded decoding to work. For FFmpeg-mt only --enable-pthreads will work.
</p>
<h2>Changes</h2>
<ul>
<li>2.00 beta 10<ul>
<li>Now checks for failed seeking when LAVF is used and retries with more aggressive seeking options before failing</li>
</ul></li>
<li>2.00 beta 9<ul>
<li>Dumping audio now actually implies indexing too in FFIndex, previously nothing would be done if the index mask wasn't set as well</li>
<li>FFAudioSource will now first load the index and returns the first indexed audio track with track=-1, if no audio tracks are indexed or the chosen track isn't indexed the equivalent of FFIndex(indexmask = -1, overwrite = cache) is executed first</li>
<li>Codec lookup for non-lavf opened files now to a large part use the same lookup tables as lavf, this should improve the number of properly recognized codecs</li>
<li>Now uses the average framerate for files opened with Haali's splitters, before it was always reported as 30 fps</li>
<li>Implemented audio decoding using Haali's splitters, FFAudioSource now works on ts, ps and ogm</li>
<li>Can now be compiled with ICL 10.1 (probably other versions too)</li>
<li>How indexing works has been split internally so the track numbers and types are reported, this makes it possible to create an interactive GUI or ask which audio tracks are to be indexed</li>
<li>Now has stricter index checking to detect when different FFmpeg versions were used to create an index of the same version</li>
<li>Fixed memory leaks when audio sources were destroyed and when errors happened during indexing</li>
<li>Fixed access violations occurring when a track of the wrong type was specified or didn't exist in FFVideoSource and FFAudioSource</li>
<li>Fixed access violations occurring when unindexed or empty audio tracks in matroska/lavf read files were opened</li>
<li>Less type conversion/signedness warnings</li>
<li>When audio track dumping is performed a custom callback can now be supplied to name the tracks</li>
<li>The audio track delay is now exposed in the API in the same way as video tracks</li>
<li>A big type and argument name cleanup in the API, many things have been renamed to be clearer and ffms.h should be completely C friendly now</li>
<li>Removed FFNoLog and replaced it with FFSetLogLevel and FFGetLogLevel, the default logging is now also set to quiet, the magical numbers to supply it can be found in avutil/log.h</li>
<li>Updated FFmpeg to rev 18972 (now with faad2 again by popular demand, updated to GCC 4.4.0 for compiling all libraries)</li>
</ul></li>
<li>2.00 beta 8<ul>
<li>Improved the audio decoding quality a lot by adding a simple cache, no more seeking is done when playing a file linearly and pops and other artifacts should be much more uncommon</li>
<li>Fixed a bug that would most of the time drop frame 0 and sometimes frame 1</li>
<li>Updated Haali's matroska parser code to the latest version</li>
<li>Updated FFmpeg to rev 18774</li>
</ul></li>
<li>2.00 beta 7<ul>
<li>Using ffms2 as a library no longer requires an installed pixfmt.h from libavutil, it is however still required to compile ffms2 and the avisynth plugin part</li>
<li>Fix a crash bug at the end of files with b-frames in beta 6 caused by uninitialized null packets</li>
<li>Includes TheFluff's wrapper function for 1.21 style syntax</li>
<li>Added a simple regression test application to the source</li>
<li>Removed a few pointless functions from the API</li>
<li>Fixed the accessing of codecprivate data with Haali's splitters</li>
<li>Timecode output should be fixed to include decimals AND not be in scientific format</li>
<li>Fixed a memory leak when using Haali's splitters</li>
<li>Updated FFmpeg to rev 18717</li>
</ul></li>
<li>2.00 beta 6<ul>
<li>Haali's splitters have been improved for video and now have audio dumping during indexing implemented</li>
<li>SeekMode=1 has improved logic which will make it go back and decode more frames if necessary to figure out where it is, in theory SeekMode=0 should now be mostly obsolete</li>
<li>Haali's splitters are now used to open mpeg ps and ogm in addition to mpeg ts, only ogm is frame accurate at this time</li>
<li>Negative timecodes and other bugs caused by an integer overflow fixed</li>
<li>Updated FFmpeg to rev 18442 (once again compilation fixes for the changes)</li>
</ul></li>
<li>2.00 beta 5<ul>
<li>FFMSIndex should now print the progress properly when another application reads its output</li>
<li>Added missing variables and explanations to the manual</li>
<li>Can now directly be compiled as a library for use in *nix</li>
<li>Fixed the missing decimals in saved timecode files</li>
</ul></li>
<li>2.00 beta 4<ul>
<li>Added the function FFNoLog which suppresses all messages from ffmpeg</li>
<li>Experimental new TS parsing using Haali's splitter (with bugs)</li>
<li>Everything is now compiled with VS2008 and GCC 4.3.2</li>
<li>Updated FFmpeg to rev 16383 (no libfaad2 this time)</li>
</ul></li>
<li>2.00 beta 3<ul>
<li>Compiled with libfaad2 again (has anyone seen a single aac file lavc can open right now?)</li>
<li>More API changes (and even more are likely to come)</li>
<li>Several access violations and memory leaks on opening and indexing files fixed</li>
<li>Added a VFR to CFR mode</li>
<li>Readded FFAudioSource support for other containers (glitches still present now and then but no separate raw cache is required and possibly less buggy)</li>
<li>Renamed the dll to FFMS2.dll, FFMS2 is now the official short name of the project</li>
<li>Updated FFmpeg to rev 15522</li>
</ul></li>
<li>2.00 beta 2<ul>
<li>More API changes (and more are likely to come)</li>
<li>Includes a simple CLI indexing application</li>
<li>FFIndex now takes a few more arguments</li>
<li>Readded FFAudioSource (only matroska supported for now)</li>
<li>Updated FFmpeg to rev 15396</li>
</ul></li>
<li>2.00 beta 1<ul>
<li>Can now be used as a stand alone library for making indices and retrieving frames</li>
<li>Rewrote most things</li>
<li>Updated FFmpeg to rev 15301</li>
</ul></li>
</ul>
</body>
</html>

BIN
aegisub/libffms/ffms2.lib
View file

Binary file not shown.

122
aegisub/libffms/ffms2rt.cpp
View file

@ -1,122 +0,0 @@
// Copyright (c) 2009 Fredrik Mellbin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
extern "C" {
#include <libavutil/log.h>
#include <libavutil/md5.h>
}
#include <cassert>
#include <iostream>
#include <fstream>
#include "ffms.h"
using namespace std;
#define VERBOSE
static int FFMS_CC UpdateProgress(int64_t Current, int64_t Total, void *Private) {
int *LastPercentage = (int *)Private;
int Percentage = int((double(Current)/double(Total)) * 100);
if (Percentage <= *LastPercentage)
return 0;
*LastPercentage = Percentage;
#ifdef VERBOSE
cout << "Indexing, please wait... " << Percentage << "% \r" << flush;
#endif
return 0;
}
void TestFullDump1(char *SrcFile, bool WithAudio) {
int Private;
int ret;
char ErrorMsg[2000];
FFMS_Init();
FFIndexer *FIdx = FFMS_CreateIndexer(SrcFile, ErrorMsg, sizeof(ErrorMsg));
assert(FIdx);
FFMS_CancelIndexing(FIdx);
FIdx = FFMS_CreateIndexer(SrcFile, ErrorMsg, sizeof(ErrorMsg));
assert(FIdx);
const char *Name = FFMS_GetCodecNameI(FIdx, 0);
FFIndex *FI = FFMS_DoIndexing(FIdx, -1, -1, FFMS_DefaultAudioFilename, NULL, false, UpdateProgress, &Private, ErrorMsg, sizeof(ErrorMsg));
assert(FI);
int vtrack = FFMS_GetFirstTrackOfType(FI, FFMS_TYPE_VIDEO, ErrorMsg, sizeof(ErrorMsg));
assert(vtrack >= 0);
int atrack = FFMS_GetFirstTrackOfType(FI, FFMS_TYPE_AUDIO, ErrorMsg, sizeof(ErrorMsg));
assert(atrack >= 0);
FFVideo *V = FFMS_CreateVideoSource(SrcFile, vtrack, FI, "", 2, 1, ErrorMsg, sizeof(ErrorMsg));
assert(V);
if (WithAudio) {
uint8_t *DB = new uint8_t[100000];
FFAudio *A = FFMS_CreateAudioSource(SrcFile, atrack, FI, ErrorMsg, sizeof(ErrorMsg));
assert(A);
const TAudioProperties *AP = FFMS_GetAudioProperties(A);
for (int i = 0; i < AP->NumSamples / 1000; i++) {
ret = FFMS_GetAudio(A, DB, i * 1000, 1000, ErrorMsg, sizeof(ErrorMsg));
assert(!ret);
}
FFMS_DestroyAudioSource(A);
delete[] DB;
}
const TVideoProperties *VP = FFMS_GetVideoProperties(V);
for (int i = 0; i < VP->NumFrames; i++) {
const TAVFrameLite *AVF = FFMS_GetFrame(V, i, ErrorMsg, sizeof(ErrorMsg));
assert(AVF);
}
FFMS_DestroyIndex(FI);
FFMS_DestroyVideoSource(V);
}
int main(int argc, char *argv[]) {
char *TestFiles1[10];
TestFiles1[0] = "[FLV1]_The_Melancholy_of_Haruhi_Suzumiya_-_Full_Clean_Ending.flv";
TestFiles1[1] = "jra_jupiter.avi";
TestFiles1[2] = "Zero1_ITV2_TS_Test.ts";
TestFiles1[3] = "zx.starship.operators.01.h264.mkv";
TestFiles1[4] = "negative-timecodes.avi";
TestFiles1[5] = "h264_16-bframes_16-references_pyramid_crash-indexing.mkv";
TestFiles1[6] = "pyramid-adaptive-10-bframes.mkv";
for (int i = 0; i < 5; i++)
TestFullDump1(TestFiles1[3], true);
/*
TestFullDump1(TestFiles1[5], false);
for (int i = 0; i < 5; i++)
TestFullDump1(TestFiles1[i], true);
TestFullDump1(TestFiles1[5], false);
*/
return 0;
}

237
aegisub/libffms/ffmsindex.cpp
View file

@ -1,237 +0,0 @@
// Copyright (c) 2008-2009 Karl Blomster
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
extern "C" {
#include <libavutil/log.h>
}
#ifdef _WIN32
#include <objbase.h>
#endif
#ifdef __UNIX__
#define _snprintf snprintf
#endif
#include <iostream>
#include <string>
#include <stdlib.h>
#include "ffms.h"
int TrackMask;
int DumpMask;
bool Overwrite;
bool IgnoreErrors;
bool Verbose;
std::string InputFile;
std::string CacheFile;
std::string AudioFile;
FFIndex *Index;
void PrintUsage () {
using namespace std;
cout << "FFmpegSource2 indexing app" << endl
<< "Usage: ffmsindex [options] inputfile [outputfile]" << endl
<< "If no output filename is specified, inputfile.ffindex will be used." << endl << endl
<< "Options:" << endl
<< "-f Force overwriting of existing index file, if any (default: no)" << endl
<< "-s Silently skip indexing of audio tracks that cannot be read (default: no)" << endl
<< "-v Be verbose; i.e. print FFmpeg warnings/diagnostics, if any (default: no)" << endl
<< "-t N Set the audio indexing mask to N (-1 means index all tracks, 0 means index none, default: 0)" << endl
<< "-d N Set the audio decoding mask to N (mask syntax same as -t, default: 0)" << endl
<< "-a NAME Set the audio output base filename to NAME (default: input filename)";
}
void ParseCMDLine (int argc, char *argv[]) {
if (argc <= 1) {
PrintUsage();
throw "";
}
// defaults
InputFile = "";
CacheFile = "";
AudioFile = "";
TrackMask = 0;
DumpMask = 0;
Overwrite = false;
IgnoreErrors = false;
Verbose = false;
// argv[0] = name of program
int i = 1;
while (i < argc) {
std::string Option = argv[i];
std::string OptionArg = "";
if (i+1 < argc)
OptionArg = argv[i+1];
if (!Option.compare("-f")) {
Overwrite = true;
} else if (!Option.compare("-s")) {
IgnoreErrors = true;
} else if (!Option.compare("-v")) {
Verbose = true;
} else if (!Option.compare("-t")) {
TrackMask = atoi(OptionArg.c_str());
i++;
} else if (!Option.compare("-d")) {
DumpMask = atoi(OptionArg.c_str());
i++;
} else if (!Option.compare("-a")) {
AudioFile = OptionArg;
i++;
} else if (InputFile.empty()) {
InputFile = argv[i];
} else if (CacheFile.empty()) {
CacheFile = argv[i];
} else {
std::cout << "Warning: ignoring unknown option " << argv[i] << std::endl;
}
i++;
}
if (InputFile.empty()) {
throw "Error: no input file specified";
}
if (CacheFile.empty()) {
CacheFile = InputFile;
CacheFile.append(".ffindex");
}
AudioFile.append("%s.%d2.w64");
}
static int FFMS_CC UpdateProgress(int64_t Current, int64_t Total, void *Private) {
using namespace std;
int *LastPercentage = (int *)Private;
int Percentage = int((double(Current)/double(Total)) * 100);
if (Percentage <= *LastPercentage)
return 0;
*LastPercentage = Percentage;
/*if (Percentage < 10)
cout << "\b\b";
else
cout << "\b\b\b"; */
cout << "Indexing, please wait... " << Percentage << "% \r" << flush;
return 0;
}
static int FFMS_CC GenAudioFilename(const char *SourceFile, int Track, const TAudioProperties *AP, char *FileName, void *Private) {
const char * FormatString = AudioFile.c_str();
if (FileName == NULL)
return _snprintf(NULL, 0, FormatString, SourceFile, Track) + 1;
else
return _snprintf(FileName, 999999, FormatString, SourceFile, Track) + 1;
}
void DoIndexing () {
char FFMSErrMsg[1024];
int MsgSize = sizeof(FFMSErrMsg);
int Progress = 0;
Index = FFMS_ReadIndex(CacheFile.c_str(), FFMSErrMsg, MsgSize);
if (Overwrite || Index == NULL) {
std::cout << "Indexing, please wait... 0% \r" << std::flush;
Index = FFMS_MakeIndex(InputFile.c_str(), TrackMask, DumpMask, &GenAudioFilename, NULL, IgnoreErrors, UpdateProgress, &Progress, FFMSErrMsg, MsgSize);
if (Index == NULL) {
std::string Err = "\nIndexing error: ";
Err.append(FFMSErrMsg);
throw Err;
}
if (Progress != 100)
std::cout << "Indexing, please wait... 100% \r" << std::flush;
std::cout << std::endl << "Writing index... ";
if (FFMS_WriteIndex(CacheFile.c_str(), Index, FFMSErrMsg, MsgSize)) {
std::string Err = "Error writing index: ";
Err.append(FFMSErrMsg);
throw Err;
}
std::cout << "done." << std::endl << std::flush;
} else {
throw "Error: index file already exists, use -f if you are sure you want to overwrite it.";
}
}
int main(int argc, char *argv[]) {
try {
ParseCMDLine(argc, argv);
} catch (const char *Error) {
std::cout << std::endl << Error << std::endl;
return 1;
} catch (std::string Error) {
std::cout << std::endl << Error << std::endl;
return 1;
} catch (...) {
std::cout << std::endl << "Unknown error" << std::endl;
return 1;
}
#ifdef _WIN32
if (FAILED(CoInitializeEx(NULL, COINIT_MULTITHREADED))) {
std::cout << "COM initialization failure" << std::endl;
return 1;
}
#endif /* _WIN32 */
FFMS_Init();
if (Verbose)
FFMS_SetLogLevel(AV_LOG_INFO);
try {
DoIndexing();
} catch (const char *Error) {
std::cout << Error << std::endl;
FFMS_DestroyIndex(Index);
return 1;
} catch (std::string Error) {
std::cout << std::endl << Error << std::endl;
FFMS_DestroyIndex(Index);
return 1;
} catch (...) {
std::cout << std::endl << "Unknown error" << std::endl;
FFMS_DestroyIndex(Index);
return 1;
}
FFMS_DestroyIndex(Index);
#ifdef _WIN32
CoUninitialize();
#endif
return 0;
}

96
aegisub/libffms/ffpp.cpp
View file

@ -1,96 +0,0 @@
// Copyright (c) 2007-2009 Fredrik Mellbin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include "ffpp.h"
#include "utils.h"
FFPP::FFPP(PClip AChild, const char *PP, IScriptEnvironment *Env) : GenericVideoFilter(AChild) {
if (!strcmp(PP, ""))
Env->ThrowError("FFPP: PP argument is empty");
PPContext = NULL;
PPMode = NULL;
SWSTo422P = NULL;
SWSFrom422P = NULL;
memset(&InputPicture, 0, sizeof(InputPicture));
memset(&OutputPicture, 0, sizeof(OutputPicture));
PPMode = pp_get_mode_by_name_and_quality((char *)PP, PP_QUALITY_MAX);
if (!PPMode)
Env->ThrowError("FFPP: Invalid postprocesing settings");
int Flags = GetCPUFlags();
if (vi.IsYV12()) {
Flags |= PP_FORMAT_420;
} else if (vi.IsYUY2()) {
Flags |= PP_FORMAT_422;
SWSTo422P = sws_getContext(vi.width, vi.height, PIX_FMT_YUYV422, vi.width, vi.height, PIX_FMT_YUV422P, GetCPUFlags() | SWS_BICUBIC, NULL, NULL, NULL);
SWSFrom422P = sws_getContext(vi.width, vi.height, PIX_FMT_YUV422P, vi.width, vi.height, PIX_FMT_YUYV422, GetCPUFlags() | SWS_BICUBIC, NULL, NULL, NULL);
avpicture_alloc(&InputPicture, PIX_FMT_YUV422P, vi.width, vi.height);
avpicture_alloc(&OutputPicture, PIX_FMT_YUV422P, vi.width, vi.height);
} else {
Env->ThrowError("FFPP: Only YV12 and YUY2 video supported");
}
PPContext = pp_get_context(vi.width, vi.height, Flags);
if (!PPContext)
Env->ThrowError("FFPP: Failed to create context");
}
FFPP::~FFPP() {
if (PPMode)
pp_free_mode(PPMode);
if (PPContext)
pp_free_context(PPContext);
if (SWSTo422P)
sws_freeContext(SWSTo422P);
if (SWSFrom422P)
sws_freeContext(SWSFrom422P);
avpicture_free(&InputPicture);
avpicture_free(&OutputPicture);
}
PVideoFrame FFPP::GetFrame(int n, IScriptEnvironment* Env) {
PVideoFrame Src = child->GetFrame(n, Env);
PVideoFrame Dst = Env->NewVideoFrame(vi);
if (vi.IsYV12()) {
const uint8_t *SrcData[3] = {(uint8_t *)Src->GetReadPtr(PLANAR_Y), (uint8_t *)Src->GetReadPtr(PLANAR_U), (uint8_t *)Src->GetReadPtr(PLANAR_V)};
int SrcStride[3] = {Src->GetPitch(PLANAR_Y), Src->GetPitch(PLANAR_U), Src->GetPitch(PLANAR_V)};
uint8_t *DstData[3] = {Dst->GetWritePtr(PLANAR_Y), Dst->GetWritePtr(PLANAR_U), Dst->GetWritePtr(PLANAR_V)};
int DstStride[3] = {Dst->GetPitch(PLANAR_Y), Dst->GetPitch(PLANAR_U), Dst->GetPitch(PLANAR_V)};
pp_postprocess(SrcData, SrcStride, DstData, DstStride, vi.width, vi.height, NULL, 0, PPMode, PPContext, 0);
} else if (vi.IsYUY2()) {
uint8_t *SrcData[1] = {(uint8_t *)Src->GetReadPtr()};
int SrcStride[1] = {Src->GetPitch()};
sws_scale(SWSTo422P, SrcData, SrcStride, 0, vi.height, InputPicture.data, InputPicture.linesize);
pp_postprocess(const_cast<const uint8_t **>(InputPicture.data), InputPicture.linesize, OutputPicture.data, OutputPicture.linesize, vi.width, vi.height, NULL, 0, PPMode, PPContext, 0);
uint8_t *DstData[1] = {Dst->GetWritePtr()};
int DstStride[1] = {Dst->GetPitch()};
sws_scale(SWSFrom422P, OutputPicture.data, OutputPicture.linesize, 0, vi.height, DstData, DstStride);
}
return Dst;
}

142
aegisub/libffms/ffswscale.cpp
View file

@ -1,142 +0,0 @@
// Copyright (c) 2007-2009 Fredrik Mellbin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include "ffswscale.h"
#include "utils.h"
static PixelFormat CSNameToPIXFMT(const char * ACSName, PixelFormat ADefault) {
if (!_stricmp(ACSName, ""))
return ADefault;
if (!_stricmp(ACSName, "YV12"))
return PIX_FMT_YUV420P;
if (!_stricmp(ACSName, "YUY2"))
return PIX_FMT_YUYV422;
if (!_stricmp(ACSName, "RGB24"))
return PIX_FMT_BGR24;
if (!_stricmp(ACSName, "RGB32"))
return PIX_FMT_RGB32;
return PIX_FMT_NONE;
}
static int ResizerNameToSWSResizer(const char *AResizerName) {
if (!_stricmp(AResizerName, "FAST_BILINEAR"))
return SWS_FAST_BILINEAR;
if (!_stricmp(AResizerName, "BILINEAR"))
return SWS_BILINEAR;
if (!_stricmp(AResizerName, "BICUBIC"))
return SWS_BICUBIC;
if (!_stricmp(AResizerName, "X"))
return SWS_X;
if (!_stricmp(AResizerName, "POINT"))
return SWS_POINT;
if (!_stricmp(AResizerName, "AREA"))
return SWS_AREA;
if (!_stricmp(AResizerName, "BICUBLIN"))
return SWS_BICUBLIN;
if (!_stricmp(AResizerName, "GAUSS"))
return SWS_GAUSS;
if (!_stricmp(AResizerName, "SINC"))
return SWS_SINC;
if (!_stricmp(AResizerName, "LANCZOS"))
return SWS_LANCZOS;
if (!_stricmp(AResizerName, "SPLINE"))
return SWS_SPLINE;
return 0;
}
SWScale::SWScale(PClip Child, int ResizeToWidth, int ResizeToHeight, const char *ResizerName, const char *ConvertToFormatName, IScriptEnvironment *Env) : GenericVideoFilter(Child) {
Context = NULL;
OrigWidth = vi.width;
OrigHeight = vi.height;
FlipOutput = vi.IsYUV();
PixelFormat ConvertFromFormat = PIX_FMT_NONE;
if (vi.IsYV12())
ConvertFromFormat = PIX_FMT_YUV420P;
if (vi.IsYUY2())
ConvertFromFormat = PIX_FMT_YUYV422;
if (vi.IsRGB24())
ConvertFromFormat = PIX_FMT_BGR24;
if (vi.IsRGB32())
ConvertFromFormat = PIX_FMT_RGB32;
if (ResizeToHeight <= 0)
ResizeToHeight = OrigHeight;
else
vi.height = ResizeToHeight;
if (ResizeToWidth <= 0)
ResizeToWidth = OrigWidth;
else
vi.width = ResizeToWidth;
PixelFormat ConvertToFormat = CSNameToPIXFMT(ConvertToFormatName, ConvertFromFormat);
if (ConvertToFormat == PIX_FMT_NONE)
Env->ThrowError("SWScale: Invalid colorspace specified (%s)", ConvertToFormatName);
switch (ConvertToFormat) {
case PIX_FMT_YUV420P: vi.pixel_type = VideoInfo::CS_I420; break;
case PIX_FMT_YUYV422: vi.pixel_type = VideoInfo::CS_YUY2; break;
case PIX_FMT_BGR24: vi.pixel_type = VideoInfo::CS_BGR24; break;
case PIX_FMT_RGB32: vi.pixel_type = VideoInfo::CS_BGR32; break;
}
FlipOutput ^= vi.IsYUV();
int Resizer = ResizerNameToSWSResizer(ResizerName);
if (Resizer == 0)
Env->ThrowError("SWScale: Invalid resizer specified (%s)", ResizerName);
if (ConvertToFormat == PIX_FMT_YUV420P && vi.height & 1)
Env->ThrowError("SWScale: mod 2 output height required");
if ((ConvertToFormat == PIX_FMT_YUV420P || ConvertToFormat == PIX_FMT_YUYV422) && vi.width & 1)
Env->ThrowError("SWScale: mod 2 output width required");
// may one day need a SWS_CS_DEFAULT in flags
Context = sws_getContext(OrigWidth, OrigHeight, ConvertFromFormat, vi.width, vi.height, ConvertToFormat, GetCPUFlags() | Resizer, NULL, NULL, NULL);
if (Context == NULL)
Env->ThrowError("SWScale: Context creation failed");
}
SWScale::~SWScale() {
if (Context)
sws_freeContext(Context);
}
PVideoFrame SWScale::GetFrame(int n, IScriptEnvironment *Env) {
PVideoFrame Src = child->GetFrame(n, Env);
PVideoFrame Dst = Env->NewVideoFrame(vi);
uint8_t *SrcData[3] = {(uint8_t *)Src->GetReadPtr(PLANAR_Y), (uint8_t *)Src->GetReadPtr(PLANAR_U), (uint8_t *)Src->GetReadPtr(PLANAR_V)};
int SrcStride[3] = {Src->GetPitch(PLANAR_Y), Src->GetPitch(PLANAR_U), Src->GetPitch(PLANAR_V)};
if (FlipOutput) {
uint8_t *DstData[3] = {Dst->GetWritePtr(PLANAR_Y) + Dst->GetPitch(PLANAR_Y) * (Dst->GetHeight(PLANAR_Y) - 1), Dst->GetWritePtr(PLANAR_U) + Dst->GetPitch(PLANAR_U) * (Dst->GetHeight(PLANAR_U) - 1), Dst->GetWritePtr(PLANAR_V) + Dst->GetPitch(PLANAR_V) * (Dst->GetHeight(PLANAR_V) - 1)};
int DstStride[3] = {-Dst->GetPitch(PLANAR_Y), -Dst->GetPitch(PLANAR_U), -Dst->GetPitch(PLANAR_V)};
sws_scale(Context, SrcData, SrcStride, 0, OrigHeight, DstData, DstStride);
} else {
uint8_t *DstData[3] = {Dst->GetWritePtr(PLANAR_Y), Dst->GetWritePtr(PLANAR_U), Dst->GetWritePtr(PLANAR_V)};
int DstStride[3] = {Dst->GetPitch(PLANAR_Y), Dst->GetPitch(PLANAR_U), Dst->GetPitch(PLANAR_V)};
sws_scale(Context, SrcData, SrcStride, 0, OrigHeight, DstData, DstStride);
}
return Dst;
}

43
aegisub/libffms/ffswscale.h
View file

@ -1,43 +0,0 @@
// Copyright (c) 2007-2009 Fredrik Mellbin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#ifndef FFSWSCALE_H
#define FFSWSCALE_H
extern "C" {
#include <libswscale/swscale.h>
}
#include <windows.h>
#include "avisynth.h"
class SWScale : public GenericVideoFilter {
private:
SwsContext *Context;
int OrigWidth;
int OrigHeight;
bool FlipOutput;
public:
SWScale(PClip Child, int ResizeToWidth, int ResizeToHeight, const char *ResizerName, const char *ConvertToFormatName, IScriptEnvironment *Env);
~SWScale();
PVideoFrame __stdcall GetFrame(int n, IScriptEnvironment *Env);
};
#endif

840
aegisub/libffms/ffvideosource.cpp
View file

@ -1,840 +0,0 @@
// Copyright (c) 2007-2009 Fredrik Mellbin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include "ffvideosource.h"
#include <errno.h>
#ifdef __UNIX__
#define _snprintf snprintf
#endif
int FFVideo::InitPP(const char *PP, PixelFormat PixelFormat, char *ErrorMsg, unsigned MsgSize) {
if (PP == NULL || !strcmp(PP, ""))
return 0;
PPMode = pp_get_mode_by_name_and_quality(PP, PP_QUALITY_MAX);
if (!PPMode) {
_snprintf(ErrorMsg, MsgSize, "Invalid postprocesing settings");
return 1;
}
int Flags = GetCPUFlags();
switch (PixelFormat) {
case PIX_FMT_YUV420P: Flags |= PP_FORMAT_420; break;
case PIX_FMT_YUV422P: Flags |= PP_FORMAT_422; break;
case PIX_FMT_YUV411P: Flags |= PP_FORMAT_411; break;
case PIX_FMT_YUV444P: Flags |= PP_FORMAT_444; break;
default:
_snprintf(ErrorMsg, MsgSize, "Input format is not supported for postprocessing");
return 2;
}
PPContext = pp_get_context(VP.Width, VP.Height, Flags);
if (!(PPFrame = avcodec_alloc_frame())) {
_snprintf(ErrorMsg, MsgSize, "Failed to allocate temporary frame");
return 3;
}
if (avpicture_alloc((AVPicture *)PPFrame, PixelFormat, VP.Width, VP.Height) < 0) {
av_free(PPFrame);
PPFrame = NULL;
_snprintf(ErrorMsg, MsgSize, "Failed to allocate picture");
return 4;
}
FinalFrame = PPFrame;
return 0;
}
TAVFrameLite *FFVideo::OutputFrame(AVFrame *Frame) {
if (PPContext) {
pp_postprocess(const_cast<const uint8_t **>(Frame->data), Frame->linesize, PPFrame->data, PPFrame->linesize, VP.Width, VP.Height, Frame->qscale_table, Frame->qstride, PPMode, PPContext, Frame->pict_type | (Frame->qscale_type ? PP_PICT_TYPE_QP2 : 0));
PPFrame->key_frame = Frame->key_frame;
PPFrame->pict_type = Frame->pict_type;
}
if (SWS) {
sws_scale(SWS, PPFrame->data, PPFrame->linesize, 0, VP.Height, FinalFrame->data, FinalFrame->linesize);
FinalFrame->key_frame = PPFrame->key_frame;
FinalFrame->pict_type = PPFrame->pict_type;
}
return reinterpret_cast<TAVFrameLite *>(FinalFrame);
}
FFVideo::FFVideo() {
memset(&VP, 0, sizeof(VP));
PPContext = NULL;
PPMode = NULL;
SWS = NULL;
LastFrameNum = 0;
CurrentFrame = 1;
CodecContext = NULL;
DecodeFrame = avcodec_alloc_frame();
PPFrame = DecodeFrame;
FinalFrame = PPFrame;
}
FFVideo::~FFVideo() {
if (PPMode)
pp_free_mode(PPMode);
if (PPContext)
pp_free_context(PPContext);
if (SWS)
sws_freeContext(SWS);
if (FinalFrame != PPFrame) {
avpicture_free((AVPicture *)FinalFrame);
av_free(FinalFrame);
}
if (PPFrame != DecodeFrame) {
avpicture_free((AVPicture *)PPFrame);
av_free(PPFrame);
}
av_free(DecodeFrame);
}
TAVFrameLite *FFVideo::GetFrameByTime(double Time, char *ErrorMsg, unsigned MsgSize) {
int Frame = Frames.ClosestFrameFromDTS((Time * 1000 * Frames.TB.Den) / Frames.TB.Num);
return GetFrame(Frame, ErrorMsg, MsgSize);
}
int FFVideo::SetOutputFormat(int64_t TargetFormats, int Width, int Height, char *ErrorMsg, unsigned MsgSize) {
int Loss;
PixelFormat OutputFormat = avcodec_find_best_pix_fmt(TargetFormats,
CodecContext->pix_fmt, 1 /* Required to prevent pointless RGB32 => RGB24 conversion */, &Loss);
if (OutputFormat == PIX_FMT_NONE) {
_snprintf(ErrorMsg, MsgSize, "No suitable output format found");
return -1;
}
SwsContext *NewSWS = NULL;
if (CodecContext->pix_fmt != OutputFormat || Width != CodecContext->width || Height != CodecContext->height) {
NewSWS = sws_getContext(CodecContext->width, CodecContext->height, CodecContext->pix_fmt, Width, Height,
OutputFormat, GetCPUFlags() | SWS_BICUBIC, NULL, NULL, NULL);
if (NewSWS == NULL) {
_snprintf(ErrorMsg, MsgSize, "Failed to allocate SWScale context");
return 1;
}
}
if (SWS)
sws_freeContext(SWS);
SWS = NewSWS;
VP.Height = Height;
VP.Width = Width;
VP.VPixelFormat = OutputFormat;
// FIXME: In theory the allocations in this part could fail just like in InitPP but whatever
if (FinalFrame != PPFrame) {
avpicture_free((AVPicture *)FinalFrame);
av_free(FinalFrame);
}
if (SWS) {
FinalFrame = avcodec_alloc_frame();
avpicture_alloc((AVPicture *)FinalFrame, static_cast<PixelFormat>(VP.VPixelFormat), VP.Width, VP.Height);
} else {
FinalFrame = PPFrame;
}
return 0;
}
void FFVideo::ResetOutputFormat() {
if (SWS)
sws_freeContext(SWS);
SWS = NULL;
VP.Height = CodecContext->height;
VP.Width = CodecContext->width;
VP.VPixelFormat = CodecContext->pix_fmt;
}
void FFLAVFVideo::Free(bool CloseCodec) {
if (CloseCodec)
avcodec_close(CodecContext);
av_close_input_file(FormatContext);
//FIXME how was it allocated? how was it deallocate? nobody knows
//av_free(FormatContext);
}
FFLAVFVideo::FFLAVFVideo(const char *SourceFile, int Track, FFIndex *Index,
const char *PP, int Threads, int SeekMode, char *ErrorMsg, unsigned MsgSize) {
FormatContext = NULL;
AVCodec *Codec = NULL;
this->SeekMode = SeekMode;
VideoTrack = Track;
Frames = (*Index)[VideoTrack];
if (Frames.size() == 0) {
_snprintf(ErrorMsg, MsgSize, "Video track contains no frames");
throw ErrorMsg;
}
if (av_open_input_file(&FormatContext, SourceFile, NULL, 0, NULL) != 0) {
_snprintf(ErrorMsg, MsgSize, "Couldn't open '%s'", SourceFile);
throw ErrorMsg;
}
if (av_find_stream_info(FormatContext) < 0) {
Free(false);
_snprintf(ErrorMsg, MsgSize, "Couldn't find stream information");
throw ErrorMsg;
}
if (SeekMode >= 0 && av_seek_frame(FormatContext, VideoTrack, Frames[0].DTS, AVSEEK_FLAG_BACKWARD) < 0) {
Free(false);
_snprintf(ErrorMsg, MsgSize, "Video track is unseekable");
throw ErrorMsg;
}
CodecContext = FormatContext->streams[VideoTrack]->codec;
CodecContext->thread_count = Threads;
Codec = avcodec_find_decoder(CodecContext->codec_id);
if (Codec == NULL) {
Free(false);
_snprintf(ErrorMsg, MsgSize, "Video codec not found");
throw ErrorMsg;
}
if (avcodec_open(CodecContext, Codec) < 0) {
Free(false);
_snprintf(ErrorMsg, MsgSize, "Could not open video codec");
throw ErrorMsg;
}
// Always try to decode a frame to make sure all required parameters are known
int64_t Dummy;
if (DecodeNextFrame(&Dummy, ErrorMsg, MsgSize)) {
Free(true);
throw ErrorMsg;
}
//VP.image_type = VideoInfo::IT_TFF;
VP.Width = CodecContext->width;
VP.Height = CodecContext->height;
VP.FPSDenominator = FormatContext->streams[VideoTrack]->time_base.num;
VP.FPSNumerator = FormatContext->streams[VideoTrack]->time_base.den;
VP.NumFrames = Frames.size();
VP.VPixelFormat = CodecContext->pix_fmt;
VP.FirstTime = ((Frames.front().DTS * Frames.TB.Num) / (double)Frames.TB.Den) / 1000;
VP.LastTime = ((Frames.back().DTS * Frames.TB.Num) / (double)Frames.TB.Den) / 1000;
if (VP.Width <= 0 || VP.Height <= 0) {
Free(true);
_snprintf(ErrorMsg, MsgSize, "Codec returned zero size video");
throw ErrorMsg;
}
// sanity check framerate
if (VP.FPSDenominator > VP.FPSNumerator || VP.FPSDenominator <= 0 || VP.FPSNumerator <= 0) {
VP.FPSDenominator = 1;
VP.FPSNumerator = 30;
}
if (InitPP(PP, CodecContext->pix_fmt, ErrorMsg, MsgSize)) {
Free(true);
throw ErrorMsg;
}
// Adjust framerate to match the duration of the first frame
if (Frames.size() >= 2) {
unsigned int DTSDiff = (unsigned int)FFMAX(Frames[1].DTS - Frames[0].DTS, 1);
VP.FPSDenominator *= DTSDiff;
}
// Cannot "output" to PPFrame without doing all other initialization
// This is the additional mess required for seekmode=-1 to work in a reasonable way
OutputFrame(DecodeFrame);
// Set AR variables
VP.SARNum = CodecContext->sample_aspect_ratio.num;
VP.SARDen = CodecContext->sample_aspect_ratio.den;
}
FFLAVFVideo::~FFLAVFVideo() {
Free(true);
}
int FFLAVFVideo::DecodeNextFrame(int64_t *AStartTime, char *ErrorMsg, unsigned MsgSize) {
AVPacket Packet;
InitNullPacket(&Packet);
int FrameFinished = 0;
*AStartTime = -1;
while (av_read_frame(FormatContext, &Packet) >= 0) {
if (Packet.stream_index == VideoTrack) {
if (*AStartTime < 0)
*AStartTime = Packet.dts;
avcodec_decode_video2(CodecContext, DecodeFrame, &FrameFinished, &Packet);
}
av_free_packet(&Packet);
if (FrameFinished)
goto Done;
}
// Flush the last frames
if (CodecContext->has_b_frames) {
AVPacket NullPacket;
InitNullPacket(&NullPacket);
avcodec_decode_video2(CodecContext, DecodeFrame, &FrameFinished, &NullPacket);
}
if (!FrameFinished)
goto Error;
// Ignore errors for now
Error:
Done:
return 0;
}
TAVFrameLite *FFLAVFVideo::GetFrame(int n, char *ErrorMsg, unsigned MsgSize) {
// PPFrame always holds frame LastFrameNum even if no PP is applied
if (LastFrameNum == n)
return OutputFrame(DecodeFrame);
bool HasSeeked = false;
int SeekOffset = 0;
int ClosestKF = 0;
if (SeekMode >= 0) {
ClosestKF = Frames.FindClosestVideoKeyFrame(n);
if (SeekMode == 0) {
if (n < CurrentFrame) {
av_seek_frame(FormatContext, VideoTrack, Frames[0].DTS, AVSEEK_FLAG_BACKWARD);
avcodec_flush_buffers(CodecContext);
CurrentFrame = 0;
}
} else {
// 10 frames is used as a margin to prevent excessive seeking since the predicted best keyframe isn't always selected by avformat
if (n < CurrentFrame || ClosestKF > CurrentFrame + 10 || (SeekMode == 3 && n > CurrentFrame + 10)) {
ReSeek:
av_seek_frame(FormatContext, VideoTrack, (SeekMode == 3) ? Frames[n].DTS : Frames[ClosestKF + SeekOffset].DTS, AVSEEK_FLAG_BACKWARD);
avcodec_flush_buffers(CodecContext);
HasSeeked = true;
}
}
} else if (n < CurrentFrame) {
_snprintf(ErrorMsg, MsgSize, "Non-linear access attempted");
return NULL;
}
do {
int64_t StartTime;
if (DecodeNextFrame(&StartTime, ErrorMsg, MsgSize))
return NULL;
if (HasSeeked) {
HasSeeked = false;
// Is the seek destination time known? Does it belong to a frame?
if (StartTime < 0 || (CurrentFrame = Frames.FrameFromDTS(StartTime)) < 0) {
switch (SeekMode) {
case 1:
// No idea where we are so go back a bit further
if (n + SeekOffset == 0) {
_snprintf(ErrorMsg, MsgSize, "Frame accurate seeking is not possible in this file\n");
return NULL;
}
SeekOffset -= FFMIN(20, n + SeekOffset);
goto ReSeek;
case 2:
case 3:
CurrentFrame = Frames.ClosestFrameFromDTS(StartTime);
break;
default:
_snprintf(ErrorMsg, MsgSize, "Failed assertion");
return NULL;
}
}
}
CurrentFrame++;
} while (CurrentFrame <= n);
LastFrameNum = n;
return OutputFrame(DecodeFrame);
}
void FFMatroskaVideo::Free(bool CloseCodec) {
if (CS)
cs_Destroy(CS);
if (MC.ST.fp) {
mkv_Close(MF);
fclose(MC.ST.fp);
}
if (CloseCodec)
avcodec_close(CodecContext);
av_free(CodecContext);
}
FFMatroskaVideo::FFMatroskaVideo(const char *SourceFile, int Track,
FFIndex *Index, const char *PP,
int Threads, char *ErrorMsg, unsigned MsgSize) {
AVCodec *Codec = NULL;
CodecContext = NULL;
TrackInfo *TI = NULL;
CS = NULL;
VideoTrack = Track;
Frames = (*Index)[VideoTrack];
if (Frames.size() == 0) {
_snprintf(ErrorMsg, MsgSize, "Video track contains no frames");
throw ErrorMsg;
}
MC.ST.fp = fopen(SourceFile, "rb");
if (MC.ST.fp == NULL) {
_snprintf(ErrorMsg, MsgSize, "Can't open '%s': %s", SourceFile, strerror(errno));
throw ErrorMsg;
}
setvbuf(MC.ST.fp, NULL, _IOFBF, CACHESIZE);
MF = mkv_OpenEx(&MC.ST.base, 0, 0, ErrorMessage, sizeof(ErrorMessage));
if (MF == NULL) {
fclose(MC.ST.fp);
_snprintf(ErrorMsg, MsgSize, "Can't parse Matroska file: %s", ErrorMessage);
throw ErrorMsg;
}
mkv_SetTrackMask(MF, ~(1 << VideoTrack));
TI = mkv_GetTrackInfo(MF, VideoTrack);
if (TI->CompEnabled) {
CS = cs_Create(MF, VideoTrack, ErrorMessage, sizeof(ErrorMessage));
if (CS == NULL) {
Free(false);
_snprintf(ErrorMsg, MsgSize, "Can't create decompressor: %s", ErrorMessage);
throw ErrorMsg;
}
}
CodecContext = avcodec_alloc_context();
CodecContext->extradata = (uint8_t *)TI->CodecPrivate;
CodecContext->extradata_size = TI->CodecPrivateSize;
CodecContext->thread_count = Threads;
Codec = avcodec_find_decoder(MatroskaToFFCodecID(TI->CodecID, TI->CodecPrivate));
if (Codec == NULL) {
Free(false);
_snprintf(ErrorMsg, MsgSize, "Video codec not found");
throw ErrorMsg;
}
if (avcodec_open(CodecContext, Codec) < 0) {
Free(false);
_snprintf(ErrorMsg, MsgSize, "Could not open video codec");
throw ErrorMsg;
}
// Always try to decode a frame to make sure all required parameters are known
int64_t Dummy;
if (DecodeNextFrame(&Dummy, ErrorMsg, MsgSize)) {
Free(true);
throw ErrorMsg;
}
VP.Width = CodecContext->width;
VP.Height = CodecContext->height;;
VP.FPSDenominator = 1;
VP.FPSNumerator = 30;
VP.NumFrames = Frames.size();
VP.VPixelFormat = CodecContext->pix_fmt;
VP.FirstTime = ((Frames.front().DTS * Frames.TB.Num) / (double)Frames.TB.Den) / 1000;
VP.LastTime = ((Frames.back().DTS * Frames.TB.Num) / (double)Frames.TB.Den) / 1000;
if (VP.Width <= 0 || VP.Height <= 0) {
Free(true);
_snprintf(ErrorMsg, MsgSize, "Codec returned zero size video");
throw ErrorMsg;
}
if (InitPP(PP, CodecContext->pix_fmt, ErrorMsg, MsgSize)) {
Free(true);
throw ErrorMsg;
}
// Calculate the average framerate
if (Frames.size() >= 2) {
double DTSDiff = (double)(Frames.back().DTS - Frames.front().DTS);
VP.FPSDenominator = (unsigned int)(DTSDiff * mkv_TruncFloat(TI->TimecodeScale) / (double)1000 / (double)(VP.NumFrames - 1) + 0.5);
VP.FPSNumerator = 1000000;
}
// 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;
}
FFMatroskaVideo::~FFMatroskaVideo() {
Free(true);
}
int FFMatroskaVideo::DecodeNextFrame(int64_t *AFirstStartTime, char *ErrorMsg, unsigned MsgSize) {
int FrameFinished = 0;
*AFirstStartTime = -1;
AVPacket Packet;
InitNullPacket(&Packet);
ulonglong StartTime, EndTime, FilePos;
unsigned int Track, FrameFlags, FrameSize;
while (mkv_ReadFrame(MF, 0, &Track, &StartTime, &EndTime, &FilePos, &FrameSize, &FrameFlags) == 0) {
if (*AFirstStartTime < 0)
*AFirstStartTime = StartTime;
if (ReadFrame(FilePos, FrameSize, CS, MC, ErrorMsg, MsgSize))
return 1;
Packet.data = MC.Buffer;
Packet.size = FrameSize;
if (FrameFlags & FRAME_KF)
Packet.flags = AV_PKT_FLAG_KEY;
else
Packet.flags = 0;
avcodec_decode_video2(CodecContext, DecodeFrame, &FrameFinished, &Packet);
if (FrameFinished)
goto Done;
}
// Flush the last frames
if (CodecContext->has_b_frames) {
AVPacket NullPacket;
InitNullPacket(&NullPacket);
avcodec_decode_video2(CodecContext, DecodeFrame, &FrameFinished, &NullPacket);
}
if (!FrameFinished)
goto Error;
Error:
Done:
return 0;
}
TAVFrameLite *FFMatroskaVideo::GetFrame(int n, char *ErrorMsg, unsigned MsgSize) {
// PPFrame always holds frame LastFrameNum even if no PP is applied
if (LastFrameNum == n)
return OutputFrame(DecodeFrame);
bool HasSeeked = false;
if (n < CurrentFrame || Frames.FindClosestVideoKeyFrame(n) > CurrentFrame) {
mkv_Seek(MF, Frames[n].DTS, MKVF_SEEK_TO_PREV_KEYFRAME_STRICT);
avcodec_flush_buffers(CodecContext);
HasSeeked = true;
}
do {
int64_t StartTime;
if (DecodeNextFrame(&StartTime, ErrorMsg, MsgSize))
return NULL;
if (HasSeeked) {
HasSeeked = false;
if (StartTime < 0 || (CurrentFrame = Frames.FrameFromDTS(StartTime)) < 0) {
_snprintf(ErrorMsg, MsgSize, "Frame accurate seeking is not possible in this file");
return NULL;
}
}
CurrentFrame++;
} while (CurrentFrame <= n);
LastFrameNum = n;
return OutputFrame(DecodeFrame);
}
#ifdef HAALISOURCE
void FFHaaliVideo::Free(bool CloseCodec) {
if (CloseCodec)
avcodec_close(CodecContext);
av_free(CodecContext);
delete[] CodecPrivate;
}
FFHaaliVideo::FFHaaliVideo(const char *SourceFile, int Track,
FFIndex *Index, const char *PP,
int Threads, int SourceMode, char *ErrorMsg, unsigned MsgSize) {
CodecPrivate = NULL;
AVCodec *Codec = NULL;
CodecContext = NULL;
VideoTrack = Track;
Frames = (*Index)[VideoTrack];
if (Frames.size() == 0) {
_snprintf(ErrorMsg, MsgSize, "Video track contains no frames");
throw ErrorMsg;
}
CLSID clsid = HAALI_TS_Parser;
if (SourceMode == 1)
clsid = HAALI_OGM_Parser;
if (FAILED(pMMC.CoCreateInstance(clsid))) {
_snprintf(ErrorMsg, MsgSize, "Can't create parser");
throw ErrorMsg;
}
CComPtr<IMemAlloc> pMA;
if (FAILED(pMA.CoCreateInstance(CLSID_MemAlloc))) {
_snprintf(ErrorMsg, MsgSize, "Can't create memory allocator");
throw ErrorMsg;
}
CComPtr<IMMStream> pMS;
if (FAILED(pMS.CoCreateInstance(CLSID_DiskFile))) {
_snprintf(ErrorMsg, MsgSize, "Can't create disk file reader");
throw ErrorMsg;
}
WCHAR WSourceFile[2048];
mbstowcs(WSourceFile, SourceFile, 2000);
CComQIPtr<IMMStreamOpen> pMSO(pMS);
if (FAILED(pMSO->Open(WSourceFile))) {
_snprintf(ErrorMsg, MsgSize, "Can't open file");
throw ErrorMsg;
}
if (FAILED(pMMC->Open(pMS, 0, NULL, pMA))) {
_snprintf(ErrorMsg, MsgSize, "Can't parse file");
throw ErrorMsg;
}
int CodecPrivateSize = 0;
int CurrentTrack = 0;
CComPtr<IEnumUnknown> pEU;
CComQIPtr<IPropertyBag> pBag;
if (SUCCEEDED(pMMC->EnumTracks(&pEU))) {
CComPtr<IUnknown> pU;
while (pEU->Next(1, &pU, NULL) == S_OK) {
if (CurrentTrack++ == Track) {
pBag = pU;
if (pBag) {
CComVariant pV;
pV.Clear();
if (SUCCEEDED(pBag->Read(L"CodecPrivate", &pV, NULL))) {
CodecPrivateSize = vtSize(pV);
CodecPrivate = new uint8_t[CodecPrivateSize];
vtCopy(pV, CodecPrivate);
}
pV.Clear();
if (SUCCEEDED(pBag->Read(L"CodecID", &pV, NULL)) && SUCCEEDED(pV.ChangeType(VT_BSTR))) {
char ACodecID[2048];
wcstombs(ACodecID, pV.bstrVal, 2000);
Codec = avcodec_find_decoder(MatroskaToFFCodecID(ACodecID, CodecPrivate));
}
}
}
pU = NULL;
}
}
CodecContext = avcodec_alloc_context();
CodecContext->extradata = CodecPrivate;
CodecContext->extradata_size = CodecPrivateSize;
CodecContext->thread_count = Threads;
if (Codec == NULL) {
Free(false);
_snprintf(ErrorMsg, MsgSize, "Video codec not found");
throw ErrorMsg;
}
if (avcodec_open(CodecContext, Codec) < 0) {
Free(false);
_snprintf(ErrorMsg, MsgSize, "Could not open video codec");
throw ErrorMsg;
}
// Always try to decode a frame to make sure all required parameters are known
int64_t Dummy;
if (DecodeNextFrame(&Dummy, ErrorMsg, MsgSize)) {
Free(true);
throw ErrorMsg;
}
VP.Width = CodecContext->width;
VP.Height = CodecContext->height;;
VP.FPSDenominator = 1;
VP.FPSNumerator = 30;
VP.NumFrames = Frames.size();
VP.VPixelFormat = CodecContext->pix_fmt;
VP.FirstTime = ((Frames.front().DTS * Frames.TB.Num) / (double)Frames.TB.Den) / 1000;
VP.LastTime = ((Frames.back().DTS * Frames.TB.Num) / (double)Frames.TB.Den) / 1000;
if (VP.Width <= 0 || VP.Height <= 0) {
Free(true);
_snprintf(ErrorMsg, MsgSize, "Codec returned zero size video");
throw ErrorMsg;
}
if (InitPP(PP, CodecContext->pix_fmt, ErrorMsg, MsgSize)) {
Free(true);
throw ErrorMsg;
}
// Calculate the average framerate
if (Frames.size() >= 2) {
double DTSDiff = (double)(Frames.back().DTS - Frames.front().DTS);
VP.FPSDenominator = (unsigned int)(DTSDiff / (double)1000 / (double)(VP.NumFrames - 1) + 0.5);
VP.FPSNumerator = 1000000;
}
// Output the already decoded frame so it isn't wasted
OutputFrame(DecodeFrame);
// Set AR variables
CComVariant pV;
pV.Clear();
if (SUCCEEDED(pBag->Read(L"Video.DisplayWidth", &pV, NULL)) && SUCCEEDED(pV.ChangeType(VT_UI4)))
VP.SARNum = pV.uiVal;
pV.Clear();
if (SUCCEEDED(pBag->Read(L"Video.DisplayHeight", &pV, NULL)) && SUCCEEDED(pV.ChangeType(VT_UI4)))
VP.SARDen = pV.uiVal;
}
FFHaaliVideo::~FFHaaliVideo() {
Free(true);
}
int FFHaaliVideo::DecodeNextFrame(int64_t *AFirstStartTime, char *ErrorMsg, unsigned MsgSize) {
int FrameFinished = 0;
*AFirstStartTime = -1;
AVPacket Packet;
InitNullPacket(&Packet);
for (;;) {
CComPtr<IMMFrame> pMMF;
if (pMMC->ReadFrame(NULL, &pMMF) != S_OK)
break;
REFERENCE_TIME Ts, Te;
if (*AFirstStartTime < 0 && SUCCEEDED(pMMF->GetTime(&Ts, &Te)))
*AFirstStartTime = Ts;
if (pMMF->GetTrack() == VideoTrack) {
BYTE *Data = NULL;
if (FAILED(pMMF->GetPointer(&Data)))
goto Error;
Packet.data = Data;
Packet.size = pMMF->GetActualDataLength();
if (pMMF->IsSyncPoint() == S_OK)
Packet.flags = AV_PKT_FLAG_KEY;
else
Packet.flags = 0;
avcodec_decode_video2(CodecContext, DecodeFrame, &FrameFinished, &Packet);
if (FrameFinished)
goto Done;
}
}
// Flush the last frames
if (CodecContext->has_b_frames) {
AVPacket NullPacket;
InitNullPacket(&NullPacket);
avcodec_decode_video2(CodecContext, DecodeFrame, &FrameFinished, &NullPacket);
}
if (!FrameFinished)
goto Error;
Error:
Done:
return 0;
}
TAVFrameLite *FFHaaliVideo::GetFrame(int n, char *ErrorMsg, unsigned MsgSize) {
// PPFrame always holds frame LastFrameNum even if no PP is applied
if (LastFrameNum == n)
return OutputFrame(DecodeFrame);
bool HasSeeked = false;
int SeekOffset = 0;
if (n < CurrentFrame || Frames.FindClosestVideoKeyFrame(n) > CurrentFrame + 10) {
ReSeek:
pMMC->Seek(Frames[n + SeekOffset].DTS, MMSF_PREV_KF);
avcodec_flush_buffers(CodecContext);
HasSeeked = true;
}
do {
int64_t StartTime;
if (DecodeNextFrame(&StartTime, ErrorMsg, MsgSize))
return NULL;
if (HasSeeked) {
HasSeeked = false;
if (StartTime < 0 || (CurrentFrame = Frames.FrameFromDTS(StartTime)) < 0) {
// No idea where we are so go back a bit further
if (n + SeekOffset == 0) {
_snprintf(ErrorMsg, MsgSize, "Frame accurate seeking is not possible in this file\n");
return NULL;
}
SeekOffset -= FFMIN(20, n + SeekOffset);
goto ReSeek;
}
}
CurrentFrame++;
} while (CurrentFrame <= n);
LastFrameNum = n;
return OutputFrame(DecodeFrame);
}
#endif // HAALISOURCE

120
aegisub/libffms/ffms.h → aegisub/libffms/include/ffms.h
View file

@ -49,6 +49,14 @@ FFMS_CLASS_TYPE FFIndexer;
FFMS_CLASS_TYPE FFIndex;
FFMS_CLASS_TYPE FFTrack;
enum FFMS_CPUFeatures {
FFMS_CPU_CAPS_MMX = 0x01,
FFMS_CPU_CAPS_MMX2 = 0x02,
FFMS_CPU_CAPS_3DNOW = 0x04,
FFMS_CPU_CAPS_ALTIVEC = 0x08,
FFMS_CPU_CAPS_BFIN = 0x10
};
enum FFMS_SeekMode {
FFMS_SEEK_LINEAR_NO_RW = -1,
FFMS_SEEK_LINEAR = 0,
@ -66,35 +74,85 @@ enum FFMS_TrackType {
FFMS_TYPE_ATTACHMENT
};
// This is a subset of the original AVFrame only containing the most used parts.
// Even if it might seem like a good idea to cast it back to a full AVFrame to
// access a few more values you really shouldn't do that. Only the values present
// in TAVFrameLite are actually updated when postprocessing is used.
struct TAVFrameLite {
uint8_t *Data[4];
int Linesize[4];
uint8_t *Base[4];
int KeyFrame;
int PictType;
enum FFMS_SampleFormat {
FFMS_FMT_U8 = 0,
FFMS_FMT_S16,
FFMS_FMT_S32,
FFMS_FMT_FLT,
FFMS_FMT_DBL
};
struct TTrackTimeBase {
enum FFMS_AudioChannel {
FFMS_CH_FRONT_LEFT = 0x00000001,
FFMS_CH_FRONT_RIGHT = 0x00000002,
FFMS_CH_FRONT_CENTER = 0x00000004,
FFMS_CH_LOW_FREQUENCY = 0x00000008,
FFMS_CH_BACK_LEFT = 0x00000010,
FFMS_CH_BACK_RIGHT = 0x00000020,
FFMS_CH_FRONT_LEFT_OF_CENTER = 0x00000040,
FFMS_CH_FRONT_RIGHT_OF_CENTER = 0x00000080,
FFMS_CH_BACK_CENTER = 0x00000100,
FFMS_CH_SIDE_LEFT = 0x00000200,
FFMS_CH_SIDE_RIGHT = 0x00000400,
FFMS_CH_TOP_CENTER = 0x00000800,
FFMS_CH_TOP_FRONT_LEFT = 0x00001000,
FFMS_CH_TOP_FRONT_CENTER = 0x00002000,
FFMS_CH_TOP_FRONT_RIGHT = 0x00004000,
FFMS_CH_TOP_BACK_LEFT = 0x00008000,
FFMS_CH_TOP_BACK_CENTER = 0x00010000,
FFMS_CH_TOP_BACK_RIGHT = 0x00020000,
FFMS_CH_STEREO_LEFT = 0x20000000,
FFMS_CH_STEREO_RIGHT = 0x40000000
};
enum FFMS_Resizers {
FFMS_RESIZER_FAST_BILINEAR = 0x01,
FFMS_RESIZER_BILINEAR = 0x02,
FFMS_RESIZER_BICUBIC = 0x04,
FFMS_RESIZER_X = 0x08,
FFMS_RESIZER_POINT = 0x10,
FFMS_RESIZER_AREA = 0x20,
FFMS_RESIZER_BICUBLIN = 0x40,
FFMS_RESIZER_GAUSS = 0x80,
FFMS_RESIZER_SINC = 0x100,
FFMS_RESIZER_LANCZOS = 0x200,
FFMS_RESIZER_SPLINE = 0x400
};
struct FFAVFrame {
uint8_t *Data[4];
int Linesize[4];
int EncodedWidth;
int EncodedHeight;
int EncodedPixelFormat;
int ScaledWidth;
int ScaledHeight;
int ConvertedPixelFormat;
int KeyFrame;
int RepeatPict;
int InterlacedFrame;
int TopFieldFirst;
char PictType;
};
struct FFTrackTimeBase {
int64_t Num;
int64_t Den;
};
#define FFMS_FRAMEINFO_COMMON int64_t DTS; bool KeyFrame;
#define FFMS_FRAMEINFO_COMMON int64_t DTS; int RepeatPict; bool KeyFrame;
struct FFFrameInfo {
FFMS_FRAMEINFO_COMMON
};
struct TVideoProperties {
struct FFVideoProperties {
int Width;
int Height;
int FPSDenominator;
int FPSNumerator;
int RFFDenominator;
int RFFNumerator;
int NumFrames;
int VPixelFormat;
int SARNum;
@ -107,56 +165,58 @@ struct TVideoProperties {
double LastTime;
};
struct TAudioProperties {
struct FFAudioProperties {
int SampleFormat;
int SampleRate;
int Channels;
int BitsPerSample;
bool Float;
int Channels;
int64_t ChannelLayout;
int64_t NumSamples;
double FirstTime;
double LastTime;
};
typedef int (FFMS_CC *TIndexCallback)(int64_t Current, int64_t Total, void *ICPrivate);
typedef int (FFMS_CC *TAudioNameCallback)(const char *SourceFile, int Track, const TAudioProperties *AP, char *FileName, void *Private);
typedef int (FFMS_CC *TAudioNameCallback)(const char *SourceFile, int Track, const FFAudioProperties *AP, char *FileName, int FNSize, void *Private);
// Most functions return 0 on success
// Functions without error message output can be assumed to never fail
FFMS_API(void) FFMS_Init();
// Functions without error message output can be assumed to never fail in a graceful way
FFMS_API(void) FFMS_Init(int CPUFeatures);
FFMS_API(int) FFMS_GetLogLevel();
FFMS_API(void) FFMS_SetLogLevel(int Level);
FFMS_API(FFVideo *) FFMS_CreateVideoSource(const char *SourceFile, int Track, FFIndex *Index, const char *PP, int Threads, int SeekMode, char *ErrorMsg, unsigned MsgSize);
FFMS_API(FFAudio *) FFMS_CreateAudioSource(const char *SourceFile, int Track, FFIndex *Index, char *ErrorMsg, unsigned MsgSize);
FFMS_API(void) FFMS_DestroyVideoSource(FFVideo *V);
FFMS_API(void) FFMS_DestroyAudioSource(FFAudio *A);
FFMS_API(const TVideoProperties *) FFMS_GetVideoProperties(FFVideo *V);
FFMS_API(const TAudioProperties *) FFMS_GetAudioProperties(FFAudio *A);
FFMS_API(const TAVFrameLite *) FFMS_GetFrame(FFVideo *V, int n, char *ErrorMsg, unsigned MsgSize);
FFMS_API(const TAVFrameLite *) FFMS_GetFrameByTime(FFVideo *V, double Time, char *ErrorMsg, unsigned MsgSize);
FFMS_API(const FFVideoProperties *) FFMS_GetVideoProperties(FFVideo *V);
FFMS_API(const FFAudioProperties *) FFMS_GetAudioProperties(FFAudio *A);
FFMS_API(const FFAVFrame *) FFMS_GetFrame(FFVideo *V, int n, char *ErrorMsg, unsigned MsgSize);
FFMS_API(const FFAVFrame *) FFMS_GetFrameByTime(FFVideo *V, double Time, char *ErrorMsg, unsigned MsgSize);
FFMS_API(int) FFMS_GetAudio(FFAudio *A, void *Buf, int64_t Start, int64_t Count, char *ErrorMsg, unsigned MsgSize);
FFMS_API(int) FFMS_SetOutputFormat(FFVideo *V, int64_t TargetFormats, int Width, int Height, char *ErrorMsg, unsigned MsgSize);
FFMS_API(void) FFMS_ResetOutputFormat(FFVideo *V);
FFMS_API(int) FFMS_SetOutputFormatV(FFVideo *V, int64_t TargetFormats, int Width, int Height, int Resizer, char *ErrorMsg, unsigned MsgSize);
FFMS_API(void) FFMS_ResetOutputFormatV(FFVideo *V);
FFMS_API(void) FFMS_DestroyIndex(FFIndex *Index);
FFMS_API(int) FFMS_GetFirstTrackOfType(FFIndex *Index, int TrackType, char *ErrorMsg, unsigned MsgSize);
FFMS_API(int) FFMS_GetFirstIndexedTrackOfType(FFIndex *Index, int TrackType, char *ErrorMsg, unsigned MsgSize);
FFMS_API(int) FFMS_GetNumTracks(FFIndex *Index);
FFMS_API(int) FFMS_GetNumTracksI(FFIndexer *Indexer);
FFMS_API(FFMS_TrackType) FFMS_GetTrackType(FFTrack *T);
FFMS_API(FFMS_TrackType) FFMS_GetTrackTypeI(FFIndexer *Indexer, int Track);
FFMS_API(int) FFMS_GetTrackType(FFTrack *T);
FFMS_API(int) FFMS_GetTrackTypeI(FFIndexer *Indexer, int Track);
FFMS_API(const char *) FFMS_GetCodecNameI(FFIndexer *Indexer, int Track);
FFMS_API(int) FFMS_GetNumFrames(FFTrack *T);
FFMS_API(const FFFrameInfo *) FFMS_GetFrameInfo(FFTrack *T, int Frame);
FFMS_API(FFTrack *) FFMS_GetTrackFromIndex(FFIndex *Index, int Track);
FFMS_API(FFTrack *) FFMS_GetTrackFromVideo(FFVideo *V);
FFMS_API(FFTrack *) FFMS_GetTrackFromAudio(FFAudio *A);
FFMS_API(const TTrackTimeBase *) FFMS_GetTimeBase(FFTrack *T);
FFMS_API(const FFTrackTimeBase *) FFMS_GetTimeBase(FFTrack *T);
FFMS_API(int) FFMS_WriteTimecodes(FFTrack *T, const char *TimecodeFile, char *ErrorMsg, unsigned MsgSize);
FFMS_API(FFIndex *) FFMS_MakeIndex(const char *SourceFile, int IndexMask, int DumpMask, TAudioNameCallback ANC, void *ANCPrivate, bool IgnoreDecodeErrors, TIndexCallback IC, void *ICPrivate, char *ErrorMsg, unsigned MsgSize);
FFMS_API(int) FFMS_DefaultAudioFilename(const char *SourceFile, int Track, const TAudioProperties *AP, char *FileName, void *Private);
FFMS_API(int) FFMS_DefaultAudioFilename(const char *SourceFile, int Track, const FFAudioProperties *AP, char *FileName, int FNSize, void *Private);
FFMS_API(FFIndexer *) FFMS_CreateIndexer(const char *SourceFile, char *ErrorMsg, unsigned MsgSize);
FFMS_API(FFIndex *) FFMS_DoIndexing(FFIndexer *Indexer, int IndexMask, int DumpMask, TAudioNameCallback ANC, void *ANCPrivate, bool IgnoreDecodeErrors, TIndexCallback IC, void *ICPrivate, char *ErrorMsg, unsigned MsgSize);
FFMS_API(void) FFMS_CancelIndexing(FFIndexer *Indexer);
FFMS_API(FFIndex *) FFMS_ReadIndex(const char *IndexFile, char *ErrorMsg, unsigned MsgSize);
FFMS_API(int) FFMS_IndexBelongsToFile(FFIndex *Index, const char *SourceFile, char *ErrorMsg, unsigned MsgSize);
FFMS_API(int) FFMS_WriteIndex(const char *IndexFile, FFIndex *Index, char *ErrorMsg, unsigned MsgSize);
FFMS_API(int) FFMS_GetPixFmt(const char *Name);

52
aegisub/libffms/ffpp.h → aegisub/libffms/include/ffmscompat.h
View file

@ -18,30 +18,32 @@
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#ifndef FFPP_H
#define FFPP_H
extern "C" {
#include <libavcodec/avcodec.h>
#include <libswscale/swscale.h>
#include <libpostproc/postprocess.h>
}
#include <windows.h>
#include "avisynth.h"
class FFPP : public GenericVideoFilter {
private:
pp_context_t *PPContext;
pp_mode_t *PPMode;
SwsContext *SWSTo422P;
SwsContext *SWSFrom422P;
AVPicture InputPicture;
AVPicture OutputPicture;
public:
FFPP(PClip AChild, const char *PP, IScriptEnvironment *Env);
~FFPP();
PVideoFrame __stdcall GetFrame(int n, IScriptEnvironment* Env);
};
#ifndef FFMSCOMPAT_H
#define FFMSCOMPAT_H
#ifdef _WIN32
# define snprintf _snprintf
# ifdef __MINGW32__
# define fseeko fseeko64
# define ftello ftello64
# else
# define fseeko _fseeki64
# define ftello _ftelli64
# endif
#endif
// Compatibility with older/newer ffmpegs
#ifdef LIBAVFORMAT_VERSION_INT
# if (LIBAVFORMAT_VERSION_INT) < (AV_VERSION_INT(52,34,1))
# define ff_codec_bmp_tags codec_bmp_tags
# define ff_codec_movvideo_tags codec_movvideo_tags
# define ff_codec_wav_tags codec_wav_tags
# endif
#endif
#ifndef AV_PKT_FLAG_KEY
# define AV_PKT_FLAG_KEY PKT_FLAG_KEY
#endif
#endif // FFMSCOMPAT_H

642
aegisub/libffms/indexing.cpp
View file

@ -1,642 +0,0 @@
// Copyright (c) 2007-2009 Fredrik Mellbin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include <iostream>
#include <fstream>
#include <set>
#include <algorithm>
#include <memory>
#include <errno.h>
#include "indexing.h"
#ifdef __UNIX__
#define _fseeki64 fseeko
#define _ftelli64 ftello
#define _snprintf snprintf
#endif
extern "C" {
#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include "MatroskaParser.h"
#include "stdiostream.h"
}
#ifdef _WIN32
# define _WIN32_DCOM
# include <windows.h>
# include <tchar.h>
# include <atlbase.h>
# include <dshow.h>
# include "CoParser.h"
# include <initguid.h>
# include "guids.h"
#endif
class MatroskaAudioContext : public SharedAudioContext {
public:
CompressedStream *CS;
uint8_t *CodecPrivate;
MatroskaAudioContext() {
CS = NULL;
CodecPrivate = NULL;
}
~MatroskaAudioContext() {
if (CTX) {
avcodec_close(CTX);
av_free(CTX);
}
if (CS)
cs_Destroy(CS);
delete[] CodecPrivate;
}
};
class FFAudioContext : public SharedAudioContext {
public:
~FFAudioContext() {
if (CTX)
avcodec_close(CTX);
}
};
#ifdef HAALISOURCE
class HaaliIndexMemory {
private:
MatroskaAudioContext *AudioContexts;
public:
HaaliIndexMemory(int Tracks, MatroskaAudioContext *&AudioContexts) {
AudioContexts = new MatroskaAudioContext[Tracks];
this->AudioContexts = AudioContexts;
}
~HaaliIndexMemory() {
delete[] AudioContexts;
}
};
#endif
class MatroskaIndexMemory {
private:
MatroskaAudioContext *AudioContexts;
MatroskaFile *MF;
MatroskaReaderContext *MC;
public:
MatroskaIndexMemory(int Tracks, MatroskaAudioContext *&AudioContexts, MatroskaFile *MF, MatroskaReaderContext *MC) {
AudioContexts = new MatroskaAudioContext[Tracks];
this->AudioContexts = AudioContexts;
this->MF = MF;
this->MC = MC;
}
~MatroskaIndexMemory() {
delete[] AudioContexts;
mkv_Close(MF);
fclose(MC->ST.fp);
}
};
class FFIndexMemory {
private:
FFAudioContext *AudioContexts;
AVFormatContext *FormatContext;
public:
FFIndexMemory(int Tracks, FFAudioContext *&AudioContexts, AVFormatContext *&FormatContext) {
AudioContexts = new FFAudioContext[Tracks];
this->AudioContexts = AudioContexts;
this->FormatContext = FormatContext;
}
~FFIndexMemory() {
delete[] AudioContexts;
av_close_input_file(FormatContext);
}
};
static bool DTSComparison(TFrameInfo FI1, TFrameInfo FI2) {
return FI1.DTS < FI2.DTS;
}
static void SortTrackIndex(FFIndex *Index) {
for (FFIndex::iterator Cur=Index->begin(); Cur!=Index->end(); Cur++)
std::sort(Cur->begin(), Cur->end(), DTSComparison);
}
bool FFIndexer::WriteAudio(SharedAudioContext &AudioContext, FFIndex *Index, int Track, int DBSize, char *ErrorMsg, unsigned MsgSize) {
// Delay writer creation until after an audio frame has been decoded. This ensures that all parameters are known when writing the headers.
if (DBSize > 0) {
if (!AudioContext.W64W) {
TAudioProperties AP;
FillAP(AP, AudioContext.CTX, (*Index)[Track]);
char *WName = new char[(*ANC)(SourceFile, Track, &AP, NULL, ANCPrivate)];
(*ANC)(SourceFile, Track, &AP, WName, ANCPrivate);
std::string WN(WName);
delete[] WName;
try {
AudioContext.W64W = new Wave64Writer(WN.c_str(), av_get_bits_per_sample_format(AudioContext.CTX->sample_fmt),
AudioContext.CTX->channels, AudioContext.CTX->sample_rate, AudioFMTIsFloat(AudioContext.CTX->sample_fmt));
} catch (...) {
_snprintf(ErrorMsg, MsgSize, "Failed to write wave data");
return false;
}
}
AudioContext.W64W->WriteData(DecodingBuffer, DBSize);
}
return true;
}
#ifdef HAALISOURCE
FFHaaliIndexer::FFHaaliIndexer(const char *Filename, int SourceMode, char *ErrorMsg, unsigned MsgSize) {
SourceFile = Filename;
this->SourceMode = SourceMode;
memset(TrackType, FFMS_TYPE_UNKNOWN, sizeof(TrackType));
memset(Codec, 0, sizeof(Codec));
memset(CodecPrivate, 0, sizeof(CodecPrivate));
memset(CodecPrivateSize, 0, sizeof(CodecPrivateSize));
CLSID clsid = HAALI_TS_Parser;
if (SourceMode == 1)
clsid = HAALI_OGM_Parser;
if (FAILED(pMMC.CoCreateInstance(clsid))) {
_snprintf(ErrorMsg, MsgSize, "Can't create parser");
throw ErrorMsg;
}
CComPtr<IMemAlloc> pMA;
if (FAILED(pMA.CoCreateInstance(CLSID_MemAlloc))) {
_snprintf(ErrorMsg, MsgSize, "Can't create memory allocator");
throw ErrorMsg;
}
CComPtr<IMMStream> pMS;
if (FAILED(pMS.CoCreateInstance(CLSID_DiskFile))) {
_snprintf(ErrorMsg, MsgSize, "Can't create disk file reader");
throw ErrorMsg;
}
WCHAR WSourceFile[2048];
mbstowcs(WSourceFile, SourceFile, 2000);
CComQIPtr<IMMStreamOpen> pMSO(pMS);
if (FAILED(pMSO->Open(WSourceFile))) {
_snprintf(ErrorMsg, MsgSize, "Can't open file");
throw ErrorMsg;
}
if (FAILED(pMMC->Open(pMS, 0, NULL, pMA))) {
_snprintf(ErrorMsg, MsgSize, "Can't parse file");
throw ErrorMsg;
}
NumTracks = 0;
CComPtr<IEnumUnknown> pEU;
if (SUCCEEDED(pMMC->EnumTracks(&pEU))) {
CComPtr<IUnknown> pU;
while (pEU->Next(1, &pU, NULL) == S_OK) {
CComQIPtr<IPropertyBag> pBag = pU;
if (pBag) {
CComVariant pV;
pV.Clear();
if (SUCCEEDED(pBag->Read(L"Type", &pV, NULL)) && SUCCEEDED(pV.ChangeType(VT_UI4)))
TrackType[NumTracks] = HaaliTrackTypeToFFTrackType(pV.uintVal);
pV.Clear();
if (SUCCEEDED(pBag->Read(L"CodecPrivate", &pV, NULL))) {
CodecPrivateSize[NumTracks] = vtSize(pV);
CodecPrivate[NumTracks] = new uint8_t[CodecPrivateSize[NumTracks]];
vtCopy(pV, CodecPrivate[NumTracks]);
}
pV.Clear();
if (SUCCEEDED(pBag->Read(L"CodecID", &pV, NULL)) && SUCCEEDED(pV.ChangeType(VT_BSTR))) {
char CodecID[2048];
wcstombs(CodecID, pV.bstrVal, 2000);
Codec[NumTracks] = avcodec_find_decoder(MatroskaToFFCodecID(CodecID, CodecPrivate[NumTracks]));
}
}
pU = NULL;
NumTracks++;
}
}
}
FFIndex *FFHaaliIndexer::DoIndexing(char *ErrorMsg, unsigned MsgSize) {
// Audio stuff
MatroskaAudioContext *AudioContexts;
HaaliIndexMemory IM = HaaliIndexMemory(NumTracks, AudioContexts);
std::auto_ptr<FFIndex> TrackIndices(new FFIndex());
TrackIndices->Decoder = 2;
if (SourceMode == 1)
TrackIndices->Decoder = 3;
for (int i = 0; i < NumTracks; i++) {
TrackIndices->push_back(FFTrack(1, 1000000000, TrackType[i]));
if (IndexMask & (1 << i) && TrackType[i] == FFMS_TYPE_AUDIO) {
AVCodecContext *AudioCodecContext = avcodec_alloc_context();
AudioCodecContext->extradata = CodecPrivate[i];
AudioCodecContext->extradata_size = CodecPrivateSize[i];
AudioContexts[i].CTX = AudioCodecContext;
if (Codec[i] == NULL) {
av_free(AudioCodecContext);
AudioContexts[i].CTX = NULL;
_snprintf(ErrorMsg, MsgSize, "Audio codec not found");
return NULL;
}
if (avcodec_open(AudioCodecContext, Codec[i]) < 0) {
av_free(AudioCodecContext);
AudioContexts[i].CTX = NULL;
_snprintf(ErrorMsg, MsgSize, "Could not open audio codec");
return NULL;
}
} else {
IndexMask &= ~(1 << i);
}
}
//
AVPacket TempPacket;
InitNullPacket(&TempPacket);
for (;;) {
if (IC) {
if ((*IC)(0, 1, ICPrivate)) {
_snprintf(ErrorMsg, MsgSize, "Cancelled by user");
return NULL;
}
}
CComPtr<IMMFrame> pMMF;
if (pMMC->ReadFrame(NULL, &pMMF) != S_OK)
break;
REFERENCE_TIME Ts, Te;
HRESULT hr = pMMF->GetTime(&Ts, &Te);
unsigned int Track = pMMF->GetTrack();
// Only create index entries for video for now to save space
if (TrackType[Track] == FFMS_TYPE_VIDEO) {
(*TrackIndices)[Track].push_back(TFrameInfo(Ts, pMMF->IsSyncPoint() == S_OK));
} else if (TrackType[Track] == FFMS_TYPE_AUDIO && (IndexMask & (1 << Track))) {
(*TrackIndices)[Track].push_back(TFrameInfo(Ts, AudioContexts[Track].CurrentSample, 0 /* FIXME? */, pMMF->GetActualDataLength(), pMMF->IsSyncPoint() == S_OK));
AVCodecContext *AudioCodecContext = AudioContexts[Track].CTX;
pMMF->GetPointer(&TempPacket.data);
TempPacket.size = pMMF->GetActualDataLength();
if (pMMF->IsSyncPoint() == S_OK)
TempPacket.flags = AV_PKT_FLAG_KEY;
else
TempPacket.flags = 0;
while (TempPacket.size > 0) {
int dbsize = AVCODEC_MAX_AUDIO_FRAME_SIZE*10;
int Ret = avcodec_decode_audio3(AudioCodecContext, DecodingBuffer, &dbsize, &TempPacket);
if (Ret < 0) {
if (IgnoreDecodeErrors) {
(*TrackIndices)[Track].clear();
IndexMask &= ~(1 << Track);
break;
} else {
_snprintf(ErrorMsg, MsgSize, "Audio decoding error");
return NULL;
}
}
if (Ret > 0) {
TempPacket.size -= Ret;
TempPacket.data += Ret;
}
if (dbsize > 0)
AudioContexts[Track].CurrentSample += (dbsize * 8) / (av_get_bits_per_sample_format(AudioCodecContext->sample_fmt) * AudioCodecContext->channels);
if (DumpMask & (1 << Track))
WriteAudio(AudioContexts[Track], TrackIndices.get(), Track, dbsize, ErrorMsg, MsgSize);
}
}
}
SortTrackIndex(TrackIndices.get());
return TrackIndices.release();
}
#endif
FFMatroskaIndexer::FFMatroskaIndexer(const char *Filename, char *ErrorMsg, unsigned MsgSize) {
memset(Codec, 0, sizeof(Codec));
SourceFile = Filename;
char ErrorMessage[256];
InitStdIoStream(&MC.ST);
MC.ST.fp = fopen(SourceFile, "rb");
if (MC.ST.fp == NULL) {
_snprintf(ErrorMsg, MsgSize, "Can't open '%s': %s", SourceFile, strerror(errno));
throw ErrorMsg;
}
setvbuf(MC.ST.fp, NULL, _IOFBF, CACHESIZE);
MF = mkv_OpenEx(&MC.ST.base, 0, 0, ErrorMessage, sizeof(ErrorMessage));
if (MF == NULL) {
fclose(MC.ST.fp);
_snprintf(ErrorMsg, MsgSize, "Can't parse Matroska file: %s", ErrorMessage);
throw ErrorMsg;
}
for (unsigned int i = 0; i < mkv_GetNumTracks(MF); i++) {
TrackInfo *TI = mkv_GetTrackInfo(MF, i);
Codec[i] = avcodec_find_decoder(MatroskaToFFCodecID(TI->CodecID, TI->CodecPrivate));
}
}
FFIndex *FFMatroskaIndexer::DoIndexing(char *ErrorMsg, unsigned MsgSize) {
char ErrorMessage[256];
// Audio stuff
MatroskaAudioContext *AudioContexts;
MatroskaIndexMemory IM = MatroskaIndexMemory(mkv_GetNumTracks(MF), AudioContexts, MF, &MC);
for (unsigned int i = 0; i < mkv_GetNumTracks(MF); i++) {
TrackInfo *TI = mkv_GetTrackInfo(MF, i);
if (IndexMask & (1 << i) && TI->Type == TT_AUDIO) {
AVCodecContext *AudioCodecContext = avcodec_alloc_context();
AudioCodecContext->extradata = (uint8_t *)TI->CodecPrivate;
AudioCodecContext->extradata_size = TI->CodecPrivateSize;
AudioContexts[i].CTX = AudioCodecContext;
if (TI->CompEnabled) {
AudioContexts[i].CS = cs_Create(MF, i, ErrorMessage, sizeof(ErrorMessage));
if (AudioContexts[i].CS == NULL) {
av_free(AudioCodecContext);
AudioContexts[i].CTX = NULL;
_snprintf(ErrorMsg, MsgSize, "Can't create decompressor: %s", ErrorMessage);
return NULL;
}
}
AVCodec *AudioCodec = Codec[i];
if (AudioCodec == NULL) {
av_free(AudioCodecContext);
AudioContexts[i].CTX = NULL;
_snprintf(ErrorMsg, MsgSize, "Audio codec not found");
return NULL;
}
if (avcodec_open(AudioCodecContext, AudioCodec) < 0) {
av_free(AudioCodecContext);
AudioContexts[i].CTX = NULL;
_snprintf(ErrorMsg, MsgSize, "Could not open audio codec");
return NULL;
}
} else {
IndexMask &= ~(1 << i);
}
}
//
int64_t CurrentPos = _ftelli64(MC.ST.fp);
_fseeki64(MC.ST.fp, 0, SEEK_END);
int64_t SourceSize = _ftelli64(MC.ST.fp);
_fseeki64(MC.ST.fp, CurrentPos, SEEK_SET);
std::auto_ptr<FFIndex> TrackIndices(new FFIndex());
TrackIndices->Decoder = 1;
for (unsigned int i = 0; i < mkv_GetNumTracks(MF); i++)
TrackIndices->push_back(FFTrack(mkv_TruncFloat(mkv_GetTrackInfo(MF, i)->TimecodeScale), 1000000, HaaliTrackTypeToFFTrackType(mkv_GetTrackInfo(MF, i)->Type)));
ulonglong StartTime, EndTime, FilePos;
unsigned int Track, FrameFlags, FrameSize;
AVPacket TempPacket;
InitNullPacket(&TempPacket);
while (mkv_ReadFrame(MF, 0, &Track, &StartTime, &EndTime, &FilePos, &FrameSize, &FrameFlags) == 0) {
// Update progress
if (IC) {
if ((*IC)(_ftelli64(MC.ST.fp), SourceSize, ICPrivate)) {
_snprintf(ErrorMsg, MsgSize, "Cancelled by user");
return NULL;
}
}
// Only create index entries for video for now to save space
if (mkv_GetTrackInfo(MF, Track)->Type == TT_VIDEO) {
(*TrackIndices)[Track].push_back(TFrameInfo(StartTime, FilePos, FrameSize, (FrameFlags & FRAME_KF) != 0));
} else if (mkv_GetTrackInfo(MF, Track)->Type == TT_AUDIO && (IndexMask & (1 << Track))) {
(*TrackIndices)[Track].push_back(TFrameInfo(StartTime, AudioContexts[Track].CurrentSample, FilePos, FrameSize, (FrameFlags & FRAME_KF) != 0));
ReadFrame(FilePos, FrameSize, AudioContexts[Track].CS, MC, ErrorMsg, MsgSize);
AVCodecContext *AudioCodecContext = AudioContexts[Track].CTX;
TempPacket.data = MC.Buffer;
TempPacket.size = FrameSize;
if ((FrameFlags & FRAME_KF) != 0)
TempPacket.flags = AV_PKT_FLAG_KEY;
else
TempPacket.flags = 0;
while (TempPacket.size > 0) {
int dbsize = AVCODEC_MAX_AUDIO_FRAME_SIZE*10;
int Ret = avcodec_decode_audio3(AudioCodecContext, DecodingBuffer, &dbsize, &TempPacket);
if (Ret < 0) {
if (IgnoreDecodeErrors) {
(*TrackIndices)[Track].clear();
IndexMask &= ~(1 << Track);
break;
} else {
_snprintf(ErrorMsg, MsgSize, "Audio decoding error");
return NULL;
}
}
if (Ret > 0) {
TempPacket.size -= Ret;
TempPacket.data += Ret;
}
if (dbsize > 0)
AudioContexts[Track].CurrentSample += (dbsize * 8) / (av_get_bits_per_sample_format(AudioCodecContext->sample_fmt) * AudioCodecContext->channels);
if (DumpMask & (1 << Track))
WriteAudio(AudioContexts[Track], TrackIndices.get(), Track, dbsize, ErrorMsg, MsgSize);
}
}
}
SortTrackIndex(TrackIndices.get());
return TrackIndices.release();
}
FFIndexer *FFIndexer::CreateFFIndexer(const char *Filename, char *ErrorMsg, unsigned MsgSize) {
AVFormatContext *FormatContext = NULL;
if (av_open_input_file(&FormatContext, Filename, NULL, 0, NULL) != 0) {
_snprintf(ErrorMsg, MsgSize, "Can't open '%s'", Filename);
return NULL;
}
// Do matroska indexing instead?
if (!strcmp(FormatContext->iformat->name, "matroska")) {
av_close_input_file(FormatContext);
return new FFMatroskaIndexer(Filename, ErrorMsg, MsgSize);
}
#ifdef HAALISOURCE
// Do haali ts indexing instead?
if (!strcmp(FormatContext->iformat->name, "mpeg") || !strcmp(FormatContext->iformat->name, "mpegts")) {
av_close_input_file(FormatContext);
return new FFHaaliIndexer(Filename, 0, ErrorMsg, MsgSize);
}
if (!strcmp(FormatContext->iformat->name, "ogg")) {
av_close_input_file(FormatContext);
return new FFHaaliIndexer(Filename, 1, ErrorMsg, MsgSize);
}
#endif
return new FFLAVFIndexer(Filename, FormatContext, ErrorMsg, MsgSize);
}
FFIndexer::FFIndexer() {
DecodingBuffer = new int16_t[AVCODEC_MAX_AUDIO_FRAME_SIZE * 5];
}
FFIndexer::~FFIndexer() {
delete[] DecodingBuffer;
}
FFLAVFIndexer::FFLAVFIndexer(const char *Filename, AVFormatContext *FormatContext, char *ErrorMsg, unsigned MsgSize) {
SourceFile = Filename;
this->FormatContext = FormatContext;
IsIndexing = false;
if (av_find_stream_info(FormatContext) < 0) {
av_close_input_file(FormatContext);
_snprintf(ErrorMsg, MsgSize, "Couldn't find stream information");
throw ErrorMsg;
}
}
FFLAVFIndexer::~FFLAVFIndexer() {
if (!IsIndexing)
av_close_input_file(FormatContext);
}
FFIndex *FFLAVFIndexer::DoIndexing(char *ErrorMsg, unsigned MsgSize) {
IsIndexing = true;
// Audio stuff
FFAudioContext *AudioContexts;
FFIndexMemory IM = FFIndexMemory(FormatContext->nb_streams, AudioContexts, FormatContext);
for (unsigned int i = 0; i < FormatContext->nb_streams; i++) {
if (IndexMask & (1 << i) && FormatContext->streams[i]->codec->codec_type == CODEC_TYPE_AUDIO) {
AVCodecContext *AudioCodecContext = FormatContext->streams[i]->codec;
AVCodec *AudioCodec = avcodec_find_decoder(AudioCodecContext->codec_id);
if (AudioCodec == NULL) {
_snprintf(ErrorMsg, MsgSize, "Audio codec not found");
return NULL;
}
if (avcodec_open(AudioCodecContext, AudioCodec) < 0) {
_snprintf(ErrorMsg, MsgSize, "Could not open audio codec");
return NULL;
}
AudioContexts[i].CTX = AudioCodecContext;
} else {
IndexMask &= ~(1 << i);
}
}
//
std::auto_ptr<FFIndex> TrackIndices(new FFIndex());
TrackIndices->Decoder = 0;
for (unsigned int i = 0; i < FormatContext->nb_streams; i++)
TrackIndices->push_back(FFTrack((int64_t)FormatContext->streams[i]->time_base.num * 1000,
FormatContext->streams[i]->time_base.den,
static_cast<FFMS_TrackType>(FormatContext->streams[i]->codec->codec_type)));
AVPacket Packet, TempPacket;
InitNullPacket(&Packet);
InitNullPacket(&TempPacket);
while (av_read_frame(FormatContext, &Packet) >= 0) {
// Update progress
if (IC) {
if ((*IC)(FormatContext->pb->pos, FormatContext->file_size, ICPrivate)) {
_snprintf(ErrorMsg, MsgSize, "Cancelled by user");
return NULL;
}
}
// Only create index entries for video for now to save space
if (FormatContext->streams[Packet.stream_index]->codec->codec_type == CODEC_TYPE_VIDEO) {
(*TrackIndices)[Packet.stream_index].push_back(TFrameInfo(Packet.dts, (Packet.flags & AV_PKT_FLAG_KEY) ? 1 : 0));
} else if (FormatContext->streams[Packet.stream_index]->codec->codec_type == CODEC_TYPE_AUDIO && (IndexMask & (1 << Packet.stream_index))) {
(*TrackIndices)[Packet.stream_index].push_back(TFrameInfo(Packet.dts, AudioContexts[Packet.stream_index].CurrentSample, (Packet.flags & AV_PKT_FLAG_KEY) ? 1 : 0));
AVCodecContext *AudioCodecContext = FormatContext->streams[Packet.stream_index]->codec;
TempPacket.data = Packet.data;
TempPacket.size = Packet.size;
while (TempPacket.size > 0) {
int dbsize = AVCODEC_MAX_AUDIO_FRAME_SIZE*10;
int Ret = avcodec_decode_audio3(AudioCodecContext, DecodingBuffer, &dbsize, &TempPacket);
if (Ret < 0) {
if (IgnoreDecodeErrors) {
(*TrackIndices)[Packet.stream_index].clear();
IndexMask &= ~(1 << Packet.stream_index);
break;
} else {
_snprintf(ErrorMsg, MsgSize, "Audio decoding error");
return NULL;
}
}
if (Ret > 0) {
TempPacket.size -= Ret;
TempPacket.data += Ret;
}
if (dbsize > 0)
AudioContexts[Packet.stream_index].CurrentSample += (dbsize * 8) / (av_get_bits_per_sample_format(AudioCodecContext->sample_fmt) * AudioCodecContext->channels);
if (DumpMask & (1 << Packet.stream_index))
WriteAudio(AudioContexts[Packet.stream_index], TrackIndices.get(), Packet.stream_index, dbsize, ErrorMsg, MsgSize);
}
}
av_free_packet(&Packet);
}
SortTrackIndex(TrackIndices.get());
return TrackIndices.release();
}

0
aegisub/libffms/src/core/.deps/.dirstamp Normal file
View file

409
aegisub/libffms/src/core/.deps/ffaudiosource.Po Normal file
View file

@ -0,0 +1,409 @@
src/core/ffaudiosource.o: src/core/ffaudiosource.cpp \
src/core/ffaudiosource.h /usr/local/include/libavformat/avformat.h \
/usr/include/time.h /usr/include/sys/cdefs.h /usr/include/sys/_null.h \
/usr/include/sys/_types.h /usr/include/machine/_types.h \
/usr/include/sys/timespec.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h \
/usr/local/include/libavcodec/avcodec.h /usr/include/errno.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/common.h /usr/include/ctype.h \
/usr/include/_ctype.h /usr/include/runetype.h /usr/include/inttypes.h \
/usr/include/machine/_inttypes.h /usr/include/sys/stdint.h \
/usr/include/machine/_stdint.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h \
/usr/include/limits.h /usr/include/sys/limits.h \
/usr/include/machine/_limits.h /usr/include/sys/syslimits.h \
/usr/include/math.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h \
/usr/include/string.h /usr/include/strings.h \
/usr/local/include/libavutil/mem.h \
/usr/local/include/libavutil/mathematics.h /usr/include/stdint.h \
/usr/local/include/libavutil/rational.h \
/usr/local/include/libavutil/intfloat_readwrite.h \
/usr/local/include/libavutil/log.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/pixfmt.h \
/usr/local/include/libavformat/avio.h \
/usr/local/include/libavutil/common.h \
/usr/local/lib/gcc-4.3.4/include/c++/vector \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/cstddef \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h \
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/new \
/usr/local/lib/gcc-4.3.4/include/c++/exception \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/list \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_list.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/list.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/memory \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_tempbuf.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_raw_storage_iter.h \
/usr/local/lib/gcc-4.3.4/include/c++/backward/auto_ptr.h \
src/core/indexing.h src/core/utils.h \
/usr/local/lib/gcc-4.3.4/include/c++/fstream \
/usr/local/lib/gcc-4.3.4/include/c++/istream \
/usr/local/lib/gcc-4.3.4/include/c++/ios \
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwchar \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/cstdio \
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/clocale /usr/include/locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/cctype \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h \
/usr/include/pthread.h /usr/include/sys/_pthreadtypes.h \
/usr/include/sys/_sigset.h /usr/include/sched.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h \
/usr/include/machine/endian.h /usr/include/sys/select.h \
/usr/include/sys/_timeval.h /usr/include/sys/unistd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h \
/usr/local/lib/gcc-4.3.4/include/c++/string \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h \
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h \
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/streambuf \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwctype /usr/include/wctype.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/ostream \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc include/ffms.h \
src/core/matroskaparser.h src/core/stdiostream.h \
/usr/local/include/libswscale/swscale.h \
/usr/local/include/libpostproc/postprocess.h include/ffmscompat.h \
src/core/wave64writer.h /usr/local/lib/gcc-4.3.4/include/c++/iostream
src/core/ffaudiosource.h:
/usr/local/include/libavformat/avformat.h:
/usr/include/time.h:
/usr/include/sys/cdefs.h:
/usr/include/sys/_null.h:
/usr/include/sys/_types.h:
/usr/include/machine/_types.h:
/usr/include/sys/timespec.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h:
/usr/local/include/libavcodec/avcodec.h:
/usr/include/errno.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/common.h:
/usr/include/ctype.h:
/usr/include/_ctype.h:
/usr/include/runetype.h:
/usr/include/inttypes.h:
/usr/include/machine/_inttypes.h:
/usr/include/sys/stdint.h:
/usr/include/machine/_stdint.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h:
/usr/include/limits.h:
/usr/include/sys/limits.h:
/usr/include/machine/_limits.h:
/usr/include/sys/syslimits.h:
/usr/include/math.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h:
/usr/include/string.h:
/usr/include/strings.h:
/usr/local/include/libavutil/mem.h:
/usr/local/include/libavutil/mathematics.h:
/usr/include/stdint.h:
/usr/local/include/libavutil/rational.h:
/usr/local/include/libavutil/intfloat_readwrite.h:
/usr/local/include/libavutil/log.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/pixfmt.h:
/usr/local/include/libavformat/avio.h:
/usr/local/include/libavutil/common.h:
/usr/local/lib/gcc-4.3.4/include/c++/vector:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/cstddef:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h:
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/new:
/usr/local/lib/gcc-4.3.4/include/c++/exception:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/list:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_list.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/list.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/memory:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_tempbuf.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_raw_storage_iter.h:
/usr/local/lib/gcc-4.3.4/include/c++/backward/auto_ptr.h:
src/core/indexing.h:
src/core/utils.h:
/usr/local/lib/gcc-4.3.4/include/c++/fstream:
/usr/local/lib/gcc-4.3.4/include/c++/istream:
/usr/local/lib/gcc-4.3.4/include/c++/ios:
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwchar:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/cstdio:
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/clocale:
/usr/include/locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/cctype:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h:
/usr/include/pthread.h:
/usr/include/sys/_pthreadtypes.h:
/usr/include/sys/_sigset.h:
/usr/include/sched.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h:
/usr/include/machine/endian.h:
/usr/include/sys/select.h:
/usr/include/sys/_timeval.h:
/usr/include/sys/unistd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h:
/usr/local/lib/gcc-4.3.4/include/c++/string:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h:
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h:
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/streambuf:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwctype:
/usr/include/wctype.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/ostream:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc:
include/ffms.h:
src/core/matroskaparser.h:
src/core/stdiostream.h:
/usr/local/include/libswscale/swscale.h:
/usr/local/include/libpostproc/postprocess.h:
include/ffmscompat.h:
src/core/wave64writer.h:
/usr/local/lib/gcc-4.3.4/include/c++/iostream:

1
aegisub/libffms/src/core/.deps/ffhaaliaudio.Po Normal file
View file

@ -0,0 +1 @@
src/core/ffhaaliaudio.o: src/core/ffhaaliaudio.cpp

1
aegisub/libffms/src/core/.deps/ffhaaliindexer.Po Normal file
View file

@ -0,0 +1 @@
src/core/ffhaaliindexer.o: src/core/ffhaaliindexer.cpp

399
aegisub/libffms/src/core/.deps/ffhaalivideo.Po Normal file
View file

@ -0,0 +1,399 @@
src/core/ffhaalivideo.o: src/core/ffhaalivideo.cpp \
src/core/ffvideosource.h /usr/local/include/libavformat/avformat.h \
/usr/include/time.h /usr/include/sys/cdefs.h /usr/include/sys/_null.h \
/usr/include/sys/_types.h /usr/include/machine/_types.h \
/usr/include/sys/timespec.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h \
/usr/local/include/libavcodec/avcodec.h /usr/include/errno.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/common.h /usr/include/ctype.h \
/usr/include/_ctype.h /usr/include/runetype.h /usr/include/inttypes.h \
/usr/include/machine/_inttypes.h /usr/include/sys/stdint.h \
/usr/include/machine/_stdint.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h \
/usr/include/limits.h /usr/include/sys/limits.h \
/usr/include/machine/_limits.h /usr/include/sys/syslimits.h \
/usr/include/math.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h \
/usr/include/string.h /usr/include/strings.h \
/usr/local/include/libavutil/mem.h \
/usr/local/include/libavutil/mathematics.h /usr/include/stdint.h \
/usr/local/include/libavutil/rational.h \
/usr/local/include/libavutil/intfloat_readwrite.h \
/usr/local/include/libavutil/log.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/pixfmt.h \
/usr/local/include/libavformat/avio.h \
/usr/local/include/libavutil/common.h \
/usr/local/include/libswscale/swscale.h \
/usr/local/include/libpostproc/postprocess.h \
/usr/local/lib/gcc-4.3.4/include/c++/vector \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/cstddef \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h \
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/new \
/usr/local/lib/gcc-4.3.4/include/c++/exception \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc \
src/core/indexing.h /usr/local/lib/gcc-4.3.4/include/c++/memory \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_tempbuf.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_raw_storage_iter.h \
/usr/local/lib/gcc-4.3.4/include/c++/backward/auto_ptr.h \
src/core/utils.h /usr/local/lib/gcc-4.3.4/include/c++/fstream \
/usr/local/lib/gcc-4.3.4/include/c++/istream \
/usr/local/lib/gcc-4.3.4/include/c++/ios \
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwchar \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/cstdio \
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/clocale /usr/include/locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/cctype \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h \
/usr/include/pthread.h /usr/include/sys/_pthreadtypes.h \
/usr/include/sys/_sigset.h /usr/include/sched.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h \
/usr/include/machine/endian.h /usr/include/sys/select.h \
/usr/include/sys/_timeval.h /usr/include/sys/unistd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h \
/usr/local/lib/gcc-4.3.4/include/c++/string \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h \
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h \
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/streambuf \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwctype /usr/include/wctype.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/ostream \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc include/ffms.h \
src/core/matroskaparser.h src/core/stdiostream.h include/ffmscompat.h \
src/core/wave64writer.h /usr/local/lib/gcc-4.3.4/include/c++/iostream
src/core/ffvideosource.h:
/usr/local/include/libavformat/avformat.h:
/usr/include/time.h:
/usr/include/sys/cdefs.h:
/usr/include/sys/_null.h:
/usr/include/sys/_types.h:
/usr/include/machine/_types.h:
/usr/include/sys/timespec.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h:
/usr/local/include/libavcodec/avcodec.h:
/usr/include/errno.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/common.h:
/usr/include/ctype.h:
/usr/include/_ctype.h:
/usr/include/runetype.h:
/usr/include/inttypes.h:
/usr/include/machine/_inttypes.h:
/usr/include/sys/stdint.h:
/usr/include/machine/_stdint.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h:
/usr/include/limits.h:
/usr/include/sys/limits.h:
/usr/include/machine/_limits.h:
/usr/include/sys/syslimits.h:
/usr/include/math.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h:
/usr/include/string.h:
/usr/include/strings.h:
/usr/local/include/libavutil/mem.h:
/usr/local/include/libavutil/mathematics.h:
/usr/include/stdint.h:
/usr/local/include/libavutil/rational.h:
/usr/local/include/libavutil/intfloat_readwrite.h:
/usr/local/include/libavutil/log.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/pixfmt.h:
/usr/local/include/libavformat/avio.h:
/usr/local/include/libavutil/common.h:
/usr/local/include/libswscale/swscale.h:
/usr/local/include/libpostproc/postprocess.h:
/usr/local/lib/gcc-4.3.4/include/c++/vector:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/cstddef:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h:
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/new:
/usr/local/lib/gcc-4.3.4/include/c++/exception:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc:
src/core/indexing.h:
/usr/local/lib/gcc-4.3.4/include/c++/memory:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_tempbuf.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_raw_storage_iter.h:
/usr/local/lib/gcc-4.3.4/include/c++/backward/auto_ptr.h:
src/core/utils.h:
/usr/local/lib/gcc-4.3.4/include/c++/fstream:
/usr/local/lib/gcc-4.3.4/include/c++/istream:
/usr/local/lib/gcc-4.3.4/include/c++/ios:
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwchar:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/cstdio:
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/clocale:
/usr/include/locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/cctype:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h:
/usr/include/pthread.h:
/usr/include/sys/_pthreadtypes.h:
/usr/include/sys/_sigset.h:
/usr/include/sched.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h:
/usr/include/machine/endian.h:
/usr/include/sys/select.h:
/usr/include/sys/_timeval.h:
/usr/include/sys/unistd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h:
/usr/local/lib/gcc-4.3.4/include/c++/string:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h:
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h:
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/streambuf:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwctype:
/usr/include/wctype.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/ostream:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc:
include/ffms.h:
src/core/matroskaparser.h:
src/core/stdiostream.h:
include/ffmscompat.h:
src/core/wave64writer.h:
/usr/local/lib/gcc-4.3.4/include/c++/iostream:

409
aegisub/libffms/src/core/.deps/fflavfaudio.Po Normal file
View file

@ -0,0 +1,409 @@
src/core/fflavfaudio.o: src/core/fflavfaudio.cpp src/core/ffaudiosource.h \
/usr/local/include/libavformat/avformat.h /usr/include/time.h \
/usr/include/sys/cdefs.h /usr/include/sys/_null.h \
/usr/include/sys/_types.h /usr/include/machine/_types.h \
/usr/include/sys/timespec.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h \
/usr/local/include/libavcodec/avcodec.h /usr/include/errno.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/common.h /usr/include/ctype.h \
/usr/include/_ctype.h /usr/include/runetype.h /usr/include/inttypes.h \
/usr/include/machine/_inttypes.h /usr/include/sys/stdint.h \
/usr/include/machine/_stdint.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h \
/usr/include/limits.h /usr/include/sys/limits.h \
/usr/include/machine/_limits.h /usr/include/sys/syslimits.h \
/usr/include/math.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h \
/usr/include/string.h /usr/include/strings.h \
/usr/local/include/libavutil/mem.h \
/usr/local/include/libavutil/mathematics.h /usr/include/stdint.h \
/usr/local/include/libavutil/rational.h \
/usr/local/include/libavutil/intfloat_readwrite.h \
/usr/local/include/libavutil/log.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/pixfmt.h \
/usr/local/include/libavformat/avio.h \
/usr/local/include/libavutil/common.h \
/usr/local/lib/gcc-4.3.4/include/c++/vector \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/cstddef \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h \
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/new \
/usr/local/lib/gcc-4.3.4/include/c++/exception \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/list \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_list.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/list.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/memory \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_tempbuf.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_raw_storage_iter.h \
/usr/local/lib/gcc-4.3.4/include/c++/backward/auto_ptr.h \
src/core/indexing.h src/core/utils.h \
/usr/local/lib/gcc-4.3.4/include/c++/fstream \
/usr/local/lib/gcc-4.3.4/include/c++/istream \
/usr/local/lib/gcc-4.3.4/include/c++/ios \
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwchar \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/cstdio \
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/clocale /usr/include/locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/cctype \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h \
/usr/include/pthread.h /usr/include/sys/_pthreadtypes.h \
/usr/include/sys/_sigset.h /usr/include/sched.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h \
/usr/include/machine/endian.h /usr/include/sys/select.h \
/usr/include/sys/_timeval.h /usr/include/sys/unistd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h \
/usr/local/lib/gcc-4.3.4/include/c++/string \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h \
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h \
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/streambuf \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwctype /usr/include/wctype.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/ostream \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc include/ffms.h \
src/core/matroskaparser.h src/core/stdiostream.h \
/usr/local/include/libswscale/swscale.h \
/usr/local/include/libpostproc/postprocess.h include/ffmscompat.h \
src/core/wave64writer.h /usr/local/lib/gcc-4.3.4/include/c++/iostream
src/core/ffaudiosource.h:
/usr/local/include/libavformat/avformat.h:
/usr/include/time.h:
/usr/include/sys/cdefs.h:
/usr/include/sys/_null.h:
/usr/include/sys/_types.h:
/usr/include/machine/_types.h:
/usr/include/sys/timespec.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h:
/usr/local/include/libavcodec/avcodec.h:
/usr/include/errno.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/common.h:
/usr/include/ctype.h:
/usr/include/_ctype.h:
/usr/include/runetype.h:
/usr/include/inttypes.h:
/usr/include/machine/_inttypes.h:
/usr/include/sys/stdint.h:
/usr/include/machine/_stdint.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h:
/usr/include/limits.h:
/usr/include/sys/limits.h:
/usr/include/machine/_limits.h:
/usr/include/sys/syslimits.h:
/usr/include/math.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h:
/usr/include/string.h:
/usr/include/strings.h:
/usr/local/include/libavutil/mem.h:
/usr/local/include/libavutil/mathematics.h:
/usr/include/stdint.h:
/usr/local/include/libavutil/rational.h:
/usr/local/include/libavutil/intfloat_readwrite.h:
/usr/local/include/libavutil/log.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/pixfmt.h:
/usr/local/include/libavformat/avio.h:
/usr/local/include/libavutil/common.h:
/usr/local/lib/gcc-4.3.4/include/c++/vector:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/cstddef:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h:
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/new:
/usr/local/lib/gcc-4.3.4/include/c++/exception:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/list:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_list.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/list.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/memory:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_tempbuf.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_raw_storage_iter.h:
/usr/local/lib/gcc-4.3.4/include/c++/backward/auto_ptr.h:
src/core/indexing.h:
src/core/utils.h:
/usr/local/lib/gcc-4.3.4/include/c++/fstream:
/usr/local/lib/gcc-4.3.4/include/c++/istream:
/usr/local/lib/gcc-4.3.4/include/c++/ios:
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwchar:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/cstdio:
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/clocale:
/usr/include/locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/cctype:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h:
/usr/include/pthread.h:
/usr/include/sys/_pthreadtypes.h:
/usr/include/sys/_sigset.h:
/usr/include/sched.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h:
/usr/include/machine/endian.h:
/usr/include/sys/select.h:
/usr/include/sys/_timeval.h:
/usr/include/sys/unistd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h:
/usr/local/lib/gcc-4.3.4/include/c++/string:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h:
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h:
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/streambuf:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwctype:
/usr/include/wctype.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/ostream:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc:
include/ffms.h:
src/core/matroskaparser.h:
src/core/stdiostream.h:
/usr/local/include/libswscale/swscale.h:
/usr/local/include/libpostproc/postprocess.h:
include/ffmscompat.h:
src/core/wave64writer.h:
/usr/local/lib/gcc-4.3.4/include/c++/iostream:

397
aegisub/libffms/src/core/.deps/fflavfindexer.Po Normal file
View file

@ -0,0 +1,397 @@
src/core/fflavfindexer.o: src/core/fflavfindexer.cpp src/core/indexing.h \
/usr/local/lib/gcc-4.3.4/include/c++/memory \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/cstddef \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h \
/usr/include/sys/_types.h /usr/include/sys/cdefs.h \
/usr/include/machine/_types.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h \
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/new \
/usr/local/lib/gcc-4.3.4/include/c++/exception \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_tempbuf.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_raw_storage_iter.h \
/usr/local/lib/gcc-4.3.4/include/c++/backward/auto_ptr.h \
src/core/utils.h /usr/local/lib/gcc-4.3.4/include/c++/vector \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/fstream \
/usr/local/lib/gcc-4.3.4/include/c++/istream \
/usr/local/lib/gcc-4.3.4/include/c++/ios \
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwchar \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h \
/usr/include/sys/_null.h /usr/include/machine/_limits.h \
/usr/include/_ctype.h /usr/include/runetype.h /usr/include/stdint.h \
/usr/include/machine/_stdint.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/cstdio \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/clocale /usr/include/locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/cctype /usr/include/ctype.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h \
/usr/include/pthread.h /usr/include/sys/_pthreadtypes.h \
/usr/include/sys/_sigset.h /usr/include/sched.h /usr/include/time.h \
/usr/include/sys/timespec.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h \
/usr/include/machine/endian.h /usr/include/sys/select.h \
/usr/include/sys/_timeval.h /usr/include/sys/unistd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h \
/usr/local/lib/gcc-4.3.4/include/c++/string \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h \
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h \
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/streambuf \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwctype /usr/include/wctype.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/ostream \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc include/ffms.h \
src/core/matroskaparser.h src/core/stdiostream.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h \
/usr/include/string.h /usr/include/strings.h \
/usr/local/include/libavformat/avformat.h \
/usr/local/include/libavcodec/avcodec.h /usr/include/errno.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/common.h /usr/include/inttypes.h \
/usr/include/machine/_inttypes.h /usr/include/sys/stdint.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h \
/usr/include/limits.h /usr/include/sys/limits.h \
/usr/include/sys/syslimits.h /usr/include/math.h \
/usr/local/include/libavutil/mem.h \
/usr/local/include/libavutil/mathematics.h \
/usr/local/include/libavutil/rational.h \
/usr/local/include/libavutil/intfloat_readwrite.h \
/usr/local/include/libavutil/log.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/pixfmt.h \
/usr/local/include/libavformat/avio.h \
/usr/local/include/libavutil/common.h \
/usr/local/include/libswscale/swscale.h \
/usr/local/include/libpostproc/postprocess.h include/ffmscompat.h \
src/core/wave64writer.h /usr/local/lib/gcc-4.3.4/include/c++/iostream
src/core/indexing.h:
/usr/local/lib/gcc-4.3.4/include/c++/memory:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/cstddef:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h:
/usr/include/sys/_types.h:
/usr/include/sys/cdefs.h:
/usr/include/machine/_types.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h:
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/new:
/usr/local/lib/gcc-4.3.4/include/c++/exception:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_tempbuf.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_raw_storage_iter.h:
/usr/local/lib/gcc-4.3.4/include/c++/backward/auto_ptr.h:
src/core/utils.h:
/usr/local/lib/gcc-4.3.4/include/c++/vector:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/fstream:
/usr/local/lib/gcc-4.3.4/include/c++/istream:
/usr/local/lib/gcc-4.3.4/include/c++/ios:
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwchar:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h:
/usr/include/sys/_null.h:
/usr/include/machine/_limits.h:
/usr/include/_ctype.h:
/usr/include/runetype.h:
/usr/include/stdint.h:
/usr/include/machine/_stdint.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/cstdio:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/clocale:
/usr/include/locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/cctype:
/usr/include/ctype.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h:
/usr/include/pthread.h:
/usr/include/sys/_pthreadtypes.h:
/usr/include/sys/_sigset.h:
/usr/include/sched.h:
/usr/include/time.h:
/usr/include/sys/timespec.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h:
/usr/include/machine/endian.h:
/usr/include/sys/select.h:
/usr/include/sys/_timeval.h:
/usr/include/sys/unistd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h:
/usr/local/lib/gcc-4.3.4/include/c++/string:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h:
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h:
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/streambuf:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwctype:
/usr/include/wctype.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/ostream:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc:
include/ffms.h:
src/core/matroskaparser.h:
src/core/stdiostream.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h:
/usr/include/string.h:
/usr/include/strings.h:
/usr/local/include/libavformat/avformat.h:
/usr/local/include/libavcodec/avcodec.h:
/usr/include/errno.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/common.h:
/usr/include/inttypes.h:
/usr/include/machine/_inttypes.h:
/usr/include/sys/stdint.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h:
/usr/include/limits.h:
/usr/include/sys/limits.h:
/usr/include/sys/syslimits.h:
/usr/include/math.h:
/usr/local/include/libavutil/mem.h:
/usr/local/include/libavutil/mathematics.h:
/usr/local/include/libavutil/rational.h:
/usr/local/include/libavutil/intfloat_readwrite.h:
/usr/local/include/libavutil/log.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/pixfmt.h:
/usr/local/include/libavformat/avio.h:
/usr/local/include/libavutil/common.h:
/usr/local/include/libswscale/swscale.h:
/usr/local/include/libpostproc/postprocess.h:
include/ffmscompat.h:
src/core/wave64writer.h:
/usr/local/lib/gcc-4.3.4/include/c++/iostream:

399
aegisub/libffms/src/core/.deps/fflavfvideo.Po Normal file
View file

@ -0,0 +1,399 @@
src/core/fflavfvideo.o: src/core/fflavfvideo.cpp src/core/ffvideosource.h \
/usr/local/include/libavformat/avformat.h /usr/include/time.h \
/usr/include/sys/cdefs.h /usr/include/sys/_null.h \
/usr/include/sys/_types.h /usr/include/machine/_types.h \
/usr/include/sys/timespec.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h \
/usr/local/include/libavcodec/avcodec.h /usr/include/errno.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/common.h /usr/include/ctype.h \
/usr/include/_ctype.h /usr/include/runetype.h /usr/include/inttypes.h \
/usr/include/machine/_inttypes.h /usr/include/sys/stdint.h \
/usr/include/machine/_stdint.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h \
/usr/include/limits.h /usr/include/sys/limits.h \
/usr/include/machine/_limits.h /usr/include/sys/syslimits.h \
/usr/include/math.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h \
/usr/include/string.h /usr/include/strings.h \
/usr/local/include/libavutil/mem.h \
/usr/local/include/libavutil/mathematics.h /usr/include/stdint.h \
/usr/local/include/libavutil/rational.h \
/usr/local/include/libavutil/intfloat_readwrite.h \
/usr/local/include/libavutil/log.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/pixfmt.h \
/usr/local/include/libavformat/avio.h \
/usr/local/include/libavutil/common.h \
/usr/local/include/libswscale/swscale.h \
/usr/local/include/libpostproc/postprocess.h \
/usr/local/lib/gcc-4.3.4/include/c++/vector \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/cstddef \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h \
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/new \
/usr/local/lib/gcc-4.3.4/include/c++/exception \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc \
src/core/indexing.h /usr/local/lib/gcc-4.3.4/include/c++/memory \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_tempbuf.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_raw_storage_iter.h \
/usr/local/lib/gcc-4.3.4/include/c++/backward/auto_ptr.h \
src/core/utils.h /usr/local/lib/gcc-4.3.4/include/c++/fstream \
/usr/local/lib/gcc-4.3.4/include/c++/istream \
/usr/local/lib/gcc-4.3.4/include/c++/ios \
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwchar \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/cstdio \
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/clocale /usr/include/locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/cctype \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h \
/usr/include/pthread.h /usr/include/sys/_pthreadtypes.h \
/usr/include/sys/_sigset.h /usr/include/sched.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h \
/usr/include/machine/endian.h /usr/include/sys/select.h \
/usr/include/sys/_timeval.h /usr/include/sys/unistd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h \
/usr/local/lib/gcc-4.3.4/include/c++/string \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h \
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h \
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/streambuf \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwctype /usr/include/wctype.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/ostream \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc include/ffms.h \
src/core/matroskaparser.h src/core/stdiostream.h include/ffmscompat.h \
src/core/wave64writer.h /usr/local/lib/gcc-4.3.4/include/c++/iostream
src/core/ffvideosource.h:
/usr/local/include/libavformat/avformat.h:
/usr/include/time.h:
/usr/include/sys/cdefs.h:
/usr/include/sys/_null.h:
/usr/include/sys/_types.h:
/usr/include/machine/_types.h:
/usr/include/sys/timespec.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h:
/usr/local/include/libavcodec/avcodec.h:
/usr/include/errno.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/common.h:
/usr/include/ctype.h:
/usr/include/_ctype.h:
/usr/include/runetype.h:
/usr/include/inttypes.h:
/usr/include/machine/_inttypes.h:
/usr/include/sys/stdint.h:
/usr/include/machine/_stdint.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h:
/usr/include/limits.h:
/usr/include/sys/limits.h:
/usr/include/machine/_limits.h:
/usr/include/sys/syslimits.h:
/usr/include/math.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h:
/usr/include/string.h:
/usr/include/strings.h:
/usr/local/include/libavutil/mem.h:
/usr/local/include/libavutil/mathematics.h:
/usr/include/stdint.h:
/usr/local/include/libavutil/rational.h:
/usr/local/include/libavutil/intfloat_readwrite.h:
/usr/local/include/libavutil/log.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/pixfmt.h:
/usr/local/include/libavformat/avio.h:
/usr/local/include/libavutil/common.h:
/usr/local/include/libswscale/swscale.h:
/usr/local/include/libpostproc/postprocess.h:
/usr/local/lib/gcc-4.3.4/include/c++/vector:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/cstddef:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h:
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/new:
/usr/local/lib/gcc-4.3.4/include/c++/exception:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc:
src/core/indexing.h:
/usr/local/lib/gcc-4.3.4/include/c++/memory:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_tempbuf.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_raw_storage_iter.h:
/usr/local/lib/gcc-4.3.4/include/c++/backward/auto_ptr.h:
src/core/utils.h:
/usr/local/lib/gcc-4.3.4/include/c++/fstream:
/usr/local/lib/gcc-4.3.4/include/c++/istream:
/usr/local/lib/gcc-4.3.4/include/c++/ios:
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwchar:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/cstdio:
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/clocale:
/usr/include/locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/cctype:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h:
/usr/include/pthread.h:
/usr/include/sys/_pthreadtypes.h:
/usr/include/sys/_sigset.h:
/usr/include/sched.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h:
/usr/include/machine/endian.h:
/usr/include/sys/select.h:
/usr/include/sys/_timeval.h:
/usr/include/sys/unistd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h:
/usr/local/lib/gcc-4.3.4/include/c++/string:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h:
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h:
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/streambuf:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwctype:
/usr/include/wctype.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/ostream:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc:
include/ffms.h:
src/core/matroskaparser.h:
src/core/stdiostream.h:
include/ffmscompat.h:
src/core/wave64writer.h:
/usr/local/lib/gcc-4.3.4/include/c++/iostream:

409
aegisub/libffms/src/core/.deps/ffmatroskaaudio.Po Normal file
View file

@ -0,0 +1,409 @@
src/core/ffmatroskaaudio.o: src/core/ffmatroskaaudio.cpp \
src/core/ffaudiosource.h /usr/local/include/libavformat/avformat.h \
/usr/include/time.h /usr/include/sys/cdefs.h /usr/include/sys/_null.h \
/usr/include/sys/_types.h /usr/include/machine/_types.h \
/usr/include/sys/timespec.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h \
/usr/local/include/libavcodec/avcodec.h /usr/include/errno.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/common.h /usr/include/ctype.h \
/usr/include/_ctype.h /usr/include/runetype.h /usr/include/inttypes.h \
/usr/include/machine/_inttypes.h /usr/include/sys/stdint.h \
/usr/include/machine/_stdint.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h \
/usr/include/limits.h /usr/include/sys/limits.h \
/usr/include/machine/_limits.h /usr/include/sys/syslimits.h \
/usr/include/math.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h \
/usr/include/string.h /usr/include/strings.h \
/usr/local/include/libavutil/mem.h \
/usr/local/include/libavutil/mathematics.h /usr/include/stdint.h \
/usr/local/include/libavutil/rational.h \
/usr/local/include/libavutil/intfloat_readwrite.h \
/usr/local/include/libavutil/log.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/pixfmt.h \
/usr/local/include/libavformat/avio.h \
/usr/local/include/libavutil/common.h \
/usr/local/lib/gcc-4.3.4/include/c++/vector \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/cstddef \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h \
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/new \
/usr/local/lib/gcc-4.3.4/include/c++/exception \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/list \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_list.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/list.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/memory \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_tempbuf.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_raw_storage_iter.h \
/usr/local/lib/gcc-4.3.4/include/c++/backward/auto_ptr.h \
src/core/indexing.h src/core/utils.h \
/usr/local/lib/gcc-4.3.4/include/c++/fstream \
/usr/local/lib/gcc-4.3.4/include/c++/istream \
/usr/local/lib/gcc-4.3.4/include/c++/ios \
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwchar \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/cstdio \
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/clocale /usr/include/locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/cctype \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h \
/usr/include/pthread.h /usr/include/sys/_pthreadtypes.h \
/usr/include/sys/_sigset.h /usr/include/sched.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h \
/usr/include/machine/endian.h /usr/include/sys/select.h \
/usr/include/sys/_timeval.h /usr/include/sys/unistd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h \
/usr/local/lib/gcc-4.3.4/include/c++/string \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h \
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h \
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/streambuf \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwctype /usr/include/wctype.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/ostream \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc include/ffms.h \
src/core/matroskaparser.h src/core/stdiostream.h \
/usr/local/include/libswscale/swscale.h \
/usr/local/include/libpostproc/postprocess.h include/ffmscompat.h \
src/core/wave64writer.h /usr/local/lib/gcc-4.3.4/include/c++/iostream
src/core/ffaudiosource.h:
/usr/local/include/libavformat/avformat.h:
/usr/include/time.h:
/usr/include/sys/cdefs.h:
/usr/include/sys/_null.h:
/usr/include/sys/_types.h:
/usr/include/machine/_types.h:
/usr/include/sys/timespec.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h:
/usr/local/include/libavcodec/avcodec.h:
/usr/include/errno.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/common.h:
/usr/include/ctype.h:
/usr/include/_ctype.h:
/usr/include/runetype.h:
/usr/include/inttypes.h:
/usr/include/machine/_inttypes.h:
/usr/include/sys/stdint.h:
/usr/include/machine/_stdint.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h:
/usr/include/limits.h:
/usr/include/sys/limits.h:
/usr/include/machine/_limits.h:
/usr/include/sys/syslimits.h:
/usr/include/math.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h:
/usr/include/string.h:
/usr/include/strings.h:
/usr/local/include/libavutil/mem.h:
/usr/local/include/libavutil/mathematics.h:
/usr/include/stdint.h:
/usr/local/include/libavutil/rational.h:
/usr/local/include/libavutil/intfloat_readwrite.h:
/usr/local/include/libavutil/log.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/pixfmt.h:
/usr/local/include/libavformat/avio.h:
/usr/local/include/libavutil/common.h:
/usr/local/lib/gcc-4.3.4/include/c++/vector:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/cstddef:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h:
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/new:
/usr/local/lib/gcc-4.3.4/include/c++/exception:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/list:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_list.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/list.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/memory:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_tempbuf.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_raw_storage_iter.h:
/usr/local/lib/gcc-4.3.4/include/c++/backward/auto_ptr.h:
src/core/indexing.h:
src/core/utils.h:
/usr/local/lib/gcc-4.3.4/include/c++/fstream:
/usr/local/lib/gcc-4.3.4/include/c++/istream:
/usr/local/lib/gcc-4.3.4/include/c++/ios:
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwchar:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/cstdio:
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/clocale:
/usr/include/locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/cctype:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h:
/usr/include/pthread.h:
/usr/include/sys/_pthreadtypes.h:
/usr/include/sys/_sigset.h:
/usr/include/sched.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h:
/usr/include/machine/endian.h:
/usr/include/sys/select.h:
/usr/include/sys/_timeval.h:
/usr/include/sys/unistd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h:
/usr/local/lib/gcc-4.3.4/include/c++/string:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h:
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h:
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/streambuf:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwctype:
/usr/include/wctype.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/ostream:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc:
include/ffms.h:
src/core/matroskaparser.h:
src/core/stdiostream.h:
/usr/local/include/libswscale/swscale.h:
/usr/local/include/libpostproc/postprocess.h:
include/ffmscompat.h:
src/core/wave64writer.h:
/usr/local/lib/gcc-4.3.4/include/c++/iostream:

397
aegisub/libffms/src/core/.deps/ffmatroskaindexer.Po Normal file
View file

@ -0,0 +1,397 @@
src/core/ffmatroskaindexer.o: src/core/ffmatroskaindexer.cpp \
src/core/indexing.h /usr/local/lib/gcc-4.3.4/include/c++/memory \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/cstddef \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h \
/usr/include/sys/_types.h /usr/include/sys/cdefs.h \
/usr/include/machine/_types.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h \
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/new \
/usr/local/lib/gcc-4.3.4/include/c++/exception \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_tempbuf.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_raw_storage_iter.h \
/usr/local/lib/gcc-4.3.4/include/c++/backward/auto_ptr.h \
src/core/utils.h /usr/local/lib/gcc-4.3.4/include/c++/vector \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/fstream \
/usr/local/lib/gcc-4.3.4/include/c++/istream \
/usr/local/lib/gcc-4.3.4/include/c++/ios \
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwchar \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h \
/usr/include/sys/_null.h /usr/include/machine/_limits.h \
/usr/include/_ctype.h /usr/include/runetype.h /usr/include/stdint.h \
/usr/include/machine/_stdint.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/cstdio \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/clocale /usr/include/locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/cctype /usr/include/ctype.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h \
/usr/include/pthread.h /usr/include/sys/_pthreadtypes.h \
/usr/include/sys/_sigset.h /usr/include/sched.h /usr/include/time.h \
/usr/include/sys/timespec.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h \
/usr/include/machine/endian.h /usr/include/sys/select.h \
/usr/include/sys/_timeval.h /usr/include/sys/unistd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h \
/usr/local/lib/gcc-4.3.4/include/c++/string \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h \
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h \
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/streambuf \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwctype /usr/include/wctype.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/ostream \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc include/ffms.h \
src/core/matroskaparser.h src/core/stdiostream.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h \
/usr/include/string.h /usr/include/strings.h \
/usr/local/include/libavformat/avformat.h \
/usr/local/include/libavcodec/avcodec.h /usr/include/errno.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/common.h /usr/include/inttypes.h \
/usr/include/machine/_inttypes.h /usr/include/sys/stdint.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h \
/usr/include/limits.h /usr/include/sys/limits.h \
/usr/include/sys/syslimits.h /usr/include/math.h \
/usr/local/include/libavutil/mem.h \
/usr/local/include/libavutil/mathematics.h \
/usr/local/include/libavutil/rational.h \
/usr/local/include/libavutil/intfloat_readwrite.h \
/usr/local/include/libavutil/log.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/pixfmt.h \
/usr/local/include/libavformat/avio.h \
/usr/local/include/libavutil/common.h \
/usr/local/include/libswscale/swscale.h \
/usr/local/include/libpostproc/postprocess.h include/ffmscompat.h \
src/core/wave64writer.h /usr/local/lib/gcc-4.3.4/include/c++/iostream
src/core/indexing.h:
/usr/local/lib/gcc-4.3.4/include/c++/memory:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/cstddef:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h:
/usr/include/sys/_types.h:
/usr/include/sys/cdefs.h:
/usr/include/machine/_types.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h:
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/new:
/usr/local/lib/gcc-4.3.4/include/c++/exception:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_tempbuf.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_raw_storage_iter.h:
/usr/local/lib/gcc-4.3.4/include/c++/backward/auto_ptr.h:
src/core/utils.h:
/usr/local/lib/gcc-4.3.4/include/c++/vector:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/fstream:
/usr/local/lib/gcc-4.3.4/include/c++/istream:
/usr/local/lib/gcc-4.3.4/include/c++/ios:
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwchar:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h:
/usr/include/sys/_null.h:
/usr/include/machine/_limits.h:
/usr/include/_ctype.h:
/usr/include/runetype.h:
/usr/include/stdint.h:
/usr/include/machine/_stdint.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/cstdio:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/clocale:
/usr/include/locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/cctype:
/usr/include/ctype.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h:
/usr/include/pthread.h:
/usr/include/sys/_pthreadtypes.h:
/usr/include/sys/_sigset.h:
/usr/include/sched.h:
/usr/include/time.h:
/usr/include/sys/timespec.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h:
/usr/include/machine/endian.h:
/usr/include/sys/select.h:
/usr/include/sys/_timeval.h:
/usr/include/sys/unistd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h:
/usr/local/lib/gcc-4.3.4/include/c++/string:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h:
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h:
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/streambuf:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwctype:
/usr/include/wctype.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/ostream:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc:
include/ffms.h:
src/core/matroskaparser.h:
src/core/stdiostream.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h:
/usr/include/string.h:
/usr/include/strings.h:
/usr/local/include/libavformat/avformat.h:
/usr/local/include/libavcodec/avcodec.h:
/usr/include/errno.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/common.h:
/usr/include/inttypes.h:
/usr/include/machine/_inttypes.h:
/usr/include/sys/stdint.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h:
/usr/include/limits.h:
/usr/include/sys/limits.h:
/usr/include/sys/syslimits.h:
/usr/include/math.h:
/usr/local/include/libavutil/mem.h:
/usr/local/include/libavutil/mathematics.h:
/usr/local/include/libavutil/rational.h:
/usr/local/include/libavutil/intfloat_readwrite.h:
/usr/local/include/libavutil/log.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/pixfmt.h:
/usr/local/include/libavformat/avio.h:
/usr/local/include/libavutil/common.h:
/usr/local/include/libswscale/swscale.h:
/usr/local/include/libpostproc/postprocess.h:
include/ffmscompat.h:
src/core/wave64writer.h:
/usr/local/lib/gcc-4.3.4/include/c++/iostream:

399
aegisub/libffms/src/core/.deps/ffmatroskavideo.Po Normal file
View file

@ -0,0 +1,399 @@
src/core/ffmatroskavideo.o: src/core/ffmatroskavideo.cpp \
src/core/ffvideosource.h /usr/local/include/libavformat/avformat.h \
/usr/include/time.h /usr/include/sys/cdefs.h /usr/include/sys/_null.h \
/usr/include/sys/_types.h /usr/include/machine/_types.h \
/usr/include/sys/timespec.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h \
/usr/local/include/libavcodec/avcodec.h /usr/include/errno.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/common.h /usr/include/ctype.h \
/usr/include/_ctype.h /usr/include/runetype.h /usr/include/inttypes.h \
/usr/include/machine/_inttypes.h /usr/include/sys/stdint.h \
/usr/include/machine/_stdint.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h \
/usr/include/limits.h /usr/include/sys/limits.h \
/usr/include/machine/_limits.h /usr/include/sys/syslimits.h \
/usr/include/math.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h \
/usr/include/string.h /usr/include/strings.h \
/usr/local/include/libavutil/mem.h \
/usr/local/include/libavutil/mathematics.h /usr/include/stdint.h \
/usr/local/include/libavutil/rational.h \
/usr/local/include/libavutil/intfloat_readwrite.h \
/usr/local/include/libavutil/log.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/pixfmt.h \
/usr/local/include/libavformat/avio.h \
/usr/local/include/libavutil/common.h \
/usr/local/include/libswscale/swscale.h \
/usr/local/include/libpostproc/postprocess.h \
/usr/local/lib/gcc-4.3.4/include/c++/vector \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/cstddef \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h \
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/new \
/usr/local/lib/gcc-4.3.4/include/c++/exception \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc \
src/core/indexing.h /usr/local/lib/gcc-4.3.4/include/c++/memory \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_tempbuf.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_raw_storage_iter.h \
/usr/local/lib/gcc-4.3.4/include/c++/backward/auto_ptr.h \
src/core/utils.h /usr/local/lib/gcc-4.3.4/include/c++/fstream \
/usr/local/lib/gcc-4.3.4/include/c++/istream \
/usr/local/lib/gcc-4.3.4/include/c++/ios \
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwchar \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/cstdio \
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/clocale /usr/include/locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/cctype \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h \
/usr/include/pthread.h /usr/include/sys/_pthreadtypes.h \
/usr/include/sys/_sigset.h /usr/include/sched.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h \
/usr/include/machine/endian.h /usr/include/sys/select.h \
/usr/include/sys/_timeval.h /usr/include/sys/unistd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h \
/usr/local/lib/gcc-4.3.4/include/c++/string \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h \
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h \
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/streambuf \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwctype /usr/include/wctype.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/ostream \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc include/ffms.h \
src/core/matroskaparser.h src/core/stdiostream.h include/ffmscompat.h \
src/core/wave64writer.h /usr/local/lib/gcc-4.3.4/include/c++/iostream
src/core/ffvideosource.h:
/usr/local/include/libavformat/avformat.h:
/usr/include/time.h:
/usr/include/sys/cdefs.h:
/usr/include/sys/_null.h:
/usr/include/sys/_types.h:
/usr/include/machine/_types.h:
/usr/include/sys/timespec.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h:
/usr/local/include/libavcodec/avcodec.h:
/usr/include/errno.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/common.h:
/usr/include/ctype.h:
/usr/include/_ctype.h:
/usr/include/runetype.h:
/usr/include/inttypes.h:
/usr/include/machine/_inttypes.h:
/usr/include/sys/stdint.h:
/usr/include/machine/_stdint.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h:
/usr/include/limits.h:
/usr/include/sys/limits.h:
/usr/include/machine/_limits.h:
/usr/include/sys/syslimits.h:
/usr/include/math.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h:
/usr/include/string.h:
/usr/include/strings.h:
/usr/local/include/libavutil/mem.h:
/usr/local/include/libavutil/mathematics.h:
/usr/include/stdint.h:
/usr/local/include/libavutil/rational.h:
/usr/local/include/libavutil/intfloat_readwrite.h:
/usr/local/include/libavutil/log.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/pixfmt.h:
/usr/local/include/libavformat/avio.h:
/usr/local/include/libavutil/common.h:
/usr/local/include/libswscale/swscale.h:
/usr/local/include/libpostproc/postprocess.h:
/usr/local/lib/gcc-4.3.4/include/c++/vector:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/cstddef:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h:
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/new:
/usr/local/lib/gcc-4.3.4/include/c++/exception:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc:
src/core/indexing.h:
/usr/local/lib/gcc-4.3.4/include/c++/memory:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_tempbuf.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_raw_storage_iter.h:
/usr/local/lib/gcc-4.3.4/include/c++/backward/auto_ptr.h:
src/core/utils.h:
/usr/local/lib/gcc-4.3.4/include/c++/fstream:
/usr/local/lib/gcc-4.3.4/include/c++/istream:
/usr/local/lib/gcc-4.3.4/include/c++/ios:
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwchar:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/cstdio:
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/clocale:
/usr/include/locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/cctype:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h:
/usr/include/pthread.h:
/usr/include/sys/_pthreadtypes.h:
/usr/include/sys/_sigset.h:
/usr/include/sched.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h:
/usr/include/machine/endian.h:
/usr/include/sys/select.h:
/usr/include/sys/_timeval.h:
/usr/include/sys/unistd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h:
/usr/local/lib/gcc-4.3.4/include/c++/string:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h:
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h:
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/streambuf:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwctype:
/usr/include/wctype.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/ostream:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc:
include/ffms.h:
src/core/matroskaparser.h:
src/core/stdiostream.h:
include/ffmscompat.h:
src/core/wave64writer.h:
/usr/local/lib/gcc-4.3.4/include/c++/iostream:

419
aegisub/libffms/src/core/.deps/ffms.Po Normal file
View file

@ -0,0 +1,419 @@
src/core/ffms.o: src/core/ffms.cpp \
/usr/local/lib/gcc-4.3.4/include/c++/sstream \
/usr/local/lib/gcc-4.3.4/include/c++/istream \
/usr/local/lib/gcc-4.3.4/include/c++/ios \
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwchar \
/usr/local/lib/gcc-4.3.4/include/c++/cstddef \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h \
/usr/include/sys/_types.h /usr/include/sys/cdefs.h \
/usr/include/machine/_types.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h \
/usr/include/sys/_null.h /usr/include/machine/_limits.h \
/usr/include/_ctype.h /usr/include/runetype.h /usr/include/stdint.h \
/usr/include/machine/_stdint.h \
/usr/local/lib/gcc-4.3.4/include/c++/exception \
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h \
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h \
/usr/local/lib/gcc-4.3.4/include/c++/cstdio \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/clocale /usr/include/locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/cctype /usr/include/ctype.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h \
/usr/include/pthread.h /usr/include/sys/_pthreadtypes.h \
/usr/include/sys/_sigset.h /usr/include/sched.h /usr/include/time.h \
/usr/include/sys/timespec.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h \
/usr/include/machine/endian.h /usr/include/sys/select.h \
/usr/include/sys/_timeval.h /usr/include/sys/unistd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h \
/usr/local/lib/gcc-4.3.4/include/c++/string \
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/new \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h \
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h \
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/streambuf \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwctype /usr/include/wctype.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/ostream \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/sstream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/iomanip include/ffms.h \
src/core/ffvideosource.h /usr/local/include/libavformat/avformat.h \
/usr/local/include/libavcodec/avcodec.h /usr/include/errno.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/common.h /usr/include/inttypes.h \
/usr/include/machine/_inttypes.h /usr/include/sys/stdint.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h \
/usr/include/limits.h /usr/include/sys/limits.h \
/usr/include/sys/syslimits.h /usr/include/math.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h \
/usr/include/string.h /usr/include/strings.h \
/usr/local/include/libavutil/mem.h \
/usr/local/include/libavutil/mathematics.h \
/usr/local/include/libavutil/rational.h \
/usr/local/include/libavutil/intfloat_readwrite.h \
/usr/local/include/libavutil/log.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/pixfmt.h \
/usr/local/include/libavformat/avio.h \
/usr/local/include/libavutil/common.h \
/usr/local/include/libswscale/swscale.h \
/usr/local/include/libpostproc/postprocess.h \
/usr/local/lib/gcc-4.3.4/include/c++/vector \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc \
src/core/indexing.h /usr/local/lib/gcc-4.3.4/include/c++/memory \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_tempbuf.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_raw_storage_iter.h \
/usr/local/lib/gcc-4.3.4/include/c++/backward/auto_ptr.h \
src/core/utils.h /usr/local/lib/gcc-4.3.4/include/c++/fstream \
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc \
src/core/matroskaparser.h src/core/stdiostream.h include/ffmscompat.h \
src/core/wave64writer.h /usr/local/lib/gcc-4.3.4/include/c++/iostream \
src/core/ffaudiosource.h /usr/local/lib/gcc-4.3.4/include/c++/list \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_list.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/list.tcc
/usr/local/lib/gcc-4.3.4/include/c++/sstream:
/usr/local/lib/gcc-4.3.4/include/c++/istream:
/usr/local/lib/gcc-4.3.4/include/c++/ios:
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwchar:
/usr/local/lib/gcc-4.3.4/include/c++/cstddef:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h:
/usr/include/sys/_types.h:
/usr/include/sys/cdefs.h:
/usr/include/machine/_types.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h:
/usr/include/sys/_null.h:
/usr/include/machine/_limits.h:
/usr/include/_ctype.h:
/usr/include/runetype.h:
/usr/include/stdint.h:
/usr/include/machine/_stdint.h:
/usr/local/lib/gcc-4.3.4/include/c++/exception:
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h:
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h:
/usr/local/lib/gcc-4.3.4/include/c++/cstdio:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/clocale:
/usr/include/locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/cctype:
/usr/include/ctype.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h:
/usr/include/pthread.h:
/usr/include/sys/_pthreadtypes.h:
/usr/include/sys/_sigset.h:
/usr/include/sched.h:
/usr/include/time.h:
/usr/include/sys/timespec.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h:
/usr/include/machine/endian.h:
/usr/include/sys/select.h:
/usr/include/sys/_timeval.h:
/usr/include/sys/unistd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h:
/usr/local/lib/gcc-4.3.4/include/c++/string:
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/new:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h:
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h:
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/streambuf:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwctype:
/usr/include/wctype.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/ostream:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/sstream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/iomanip:
include/ffms.h:
src/core/ffvideosource.h:
/usr/local/include/libavformat/avformat.h:
/usr/local/include/libavcodec/avcodec.h:
/usr/include/errno.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/common.h:
/usr/include/inttypes.h:
/usr/include/machine/_inttypes.h:
/usr/include/sys/stdint.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h:
/usr/include/limits.h:
/usr/include/sys/limits.h:
/usr/include/sys/syslimits.h:
/usr/include/math.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h:
/usr/include/string.h:
/usr/include/strings.h:
/usr/local/include/libavutil/mem.h:
/usr/local/include/libavutil/mathematics.h:
/usr/local/include/libavutil/rational.h:
/usr/local/include/libavutil/intfloat_readwrite.h:
/usr/local/include/libavutil/log.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/pixfmt.h:
/usr/local/include/libavformat/avio.h:
/usr/local/include/libavutil/common.h:
/usr/local/include/libswscale/swscale.h:
/usr/local/include/libpostproc/postprocess.h:
/usr/local/lib/gcc-4.3.4/include/c++/vector:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc:
src/core/indexing.h:
/usr/local/lib/gcc-4.3.4/include/c++/memory:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_tempbuf.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_raw_storage_iter.h:
/usr/local/lib/gcc-4.3.4/include/c++/backward/auto_ptr.h:
src/core/utils.h:
/usr/local/lib/gcc-4.3.4/include/c++/fstream:
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc:
src/core/matroskaparser.h:
src/core/stdiostream.h:
include/ffmscompat.h:
src/core/wave64writer.h:
/usr/local/lib/gcc-4.3.4/include/c++/iostream:
src/core/ffaudiosource.h:
/usr/local/lib/gcc-4.3.4/include/c++/list:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_list.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/list.tcc:

399
aegisub/libffms/src/core/.deps/ffvideosource.Po Normal file
View file

@ -0,0 +1,399 @@
src/core/ffvideosource.o: src/core/ffvideosource.cpp \
src/core/ffvideosource.h /usr/local/include/libavformat/avformat.h \
/usr/include/time.h /usr/include/sys/cdefs.h /usr/include/sys/_null.h \
/usr/include/sys/_types.h /usr/include/machine/_types.h \
/usr/include/sys/timespec.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h \
/usr/local/include/libavcodec/avcodec.h /usr/include/errno.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/common.h /usr/include/ctype.h \
/usr/include/_ctype.h /usr/include/runetype.h /usr/include/inttypes.h \
/usr/include/machine/_inttypes.h /usr/include/sys/stdint.h \
/usr/include/machine/_stdint.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h \
/usr/include/limits.h /usr/include/sys/limits.h \
/usr/include/machine/_limits.h /usr/include/sys/syslimits.h \
/usr/include/math.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h \
/usr/include/string.h /usr/include/strings.h \
/usr/local/include/libavutil/mem.h \
/usr/local/include/libavutil/mathematics.h /usr/include/stdint.h \
/usr/local/include/libavutil/rational.h \
/usr/local/include/libavutil/intfloat_readwrite.h \
/usr/local/include/libavutil/log.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/pixfmt.h \
/usr/local/include/libavformat/avio.h \
/usr/local/include/libavutil/common.h \
/usr/local/include/libswscale/swscale.h \
/usr/local/include/libpostproc/postprocess.h \
/usr/local/lib/gcc-4.3.4/include/c++/vector \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/cstddef \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h \
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/new \
/usr/local/lib/gcc-4.3.4/include/c++/exception \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc \
src/core/indexing.h /usr/local/lib/gcc-4.3.4/include/c++/memory \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_tempbuf.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_raw_storage_iter.h \
/usr/local/lib/gcc-4.3.4/include/c++/backward/auto_ptr.h \
src/core/utils.h /usr/local/lib/gcc-4.3.4/include/c++/fstream \
/usr/local/lib/gcc-4.3.4/include/c++/istream \
/usr/local/lib/gcc-4.3.4/include/c++/ios \
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwchar \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/cstdio \
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/clocale /usr/include/locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/cctype \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h \
/usr/include/pthread.h /usr/include/sys/_pthreadtypes.h \
/usr/include/sys/_sigset.h /usr/include/sched.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h \
/usr/include/machine/endian.h /usr/include/sys/select.h \
/usr/include/sys/_timeval.h /usr/include/sys/unistd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h \
/usr/local/lib/gcc-4.3.4/include/c++/string \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h \
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h \
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/streambuf \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwctype /usr/include/wctype.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/ostream \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc include/ffms.h \
src/core/matroskaparser.h src/core/stdiostream.h include/ffmscompat.h \
src/core/wave64writer.h /usr/local/lib/gcc-4.3.4/include/c++/iostream
src/core/ffvideosource.h:
/usr/local/include/libavformat/avformat.h:
/usr/include/time.h:
/usr/include/sys/cdefs.h:
/usr/include/sys/_null.h:
/usr/include/sys/_types.h:
/usr/include/machine/_types.h:
/usr/include/sys/timespec.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h:
/usr/local/include/libavcodec/avcodec.h:
/usr/include/errno.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/common.h:
/usr/include/ctype.h:
/usr/include/_ctype.h:
/usr/include/runetype.h:
/usr/include/inttypes.h:
/usr/include/machine/_inttypes.h:
/usr/include/sys/stdint.h:
/usr/include/machine/_stdint.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h:
/usr/include/limits.h:
/usr/include/sys/limits.h:
/usr/include/machine/_limits.h:
/usr/include/sys/syslimits.h:
/usr/include/math.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h:
/usr/include/string.h:
/usr/include/strings.h:
/usr/local/include/libavutil/mem.h:
/usr/local/include/libavutil/mathematics.h:
/usr/include/stdint.h:
/usr/local/include/libavutil/rational.h:
/usr/local/include/libavutil/intfloat_readwrite.h:
/usr/local/include/libavutil/log.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/pixfmt.h:
/usr/local/include/libavformat/avio.h:
/usr/local/include/libavutil/common.h:
/usr/local/include/libswscale/swscale.h:
/usr/local/include/libpostproc/postprocess.h:
/usr/local/lib/gcc-4.3.4/include/c++/vector:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/cstddef:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h:
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/new:
/usr/local/lib/gcc-4.3.4/include/c++/exception:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc:
src/core/indexing.h:
/usr/local/lib/gcc-4.3.4/include/c++/memory:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_tempbuf.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_raw_storage_iter.h:
/usr/local/lib/gcc-4.3.4/include/c++/backward/auto_ptr.h:
src/core/utils.h:
/usr/local/lib/gcc-4.3.4/include/c++/fstream:
/usr/local/lib/gcc-4.3.4/include/c++/istream:
/usr/local/lib/gcc-4.3.4/include/c++/ios:
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwchar:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/cstdio:
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/clocale:
/usr/include/locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/cctype:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h:
/usr/include/pthread.h:
/usr/include/sys/_pthreadtypes.h:
/usr/include/sys/_sigset.h:
/usr/include/sched.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h:
/usr/include/machine/endian.h:
/usr/include/sys/select.h:
/usr/include/sys/_timeval.h:
/usr/include/sys/unistd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h:
/usr/local/lib/gcc-4.3.4/include/c++/string:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h:
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h:
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/streambuf:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwctype:
/usr/include/wctype.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/ostream:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc:
include/ffms.h:
src/core/matroskaparser.h:
src/core/stdiostream.h:
include/ffmscompat.h:
src/core/wave64writer.h:
/usr/local/lib/gcc-4.3.4/include/c++/iostream:

415
aegisub/libffms/src/core/.deps/indexing.Po Normal file
View file

@ -0,0 +1,415 @@
src/core/indexing.o: src/core/indexing.cpp src/core/indexing.h \
/usr/local/lib/gcc-4.3.4/include/c++/memory \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/cstddef \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h \
/usr/include/sys/_types.h /usr/include/sys/cdefs.h \
/usr/include/machine/_types.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h \
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/new \
/usr/local/lib/gcc-4.3.4/include/c++/exception \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_tempbuf.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_raw_storage_iter.h \
/usr/local/lib/gcc-4.3.4/include/c++/backward/auto_ptr.h \
src/core/utils.h /usr/local/lib/gcc-4.3.4/include/c++/vector \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/fstream \
/usr/local/lib/gcc-4.3.4/include/c++/istream \
/usr/local/lib/gcc-4.3.4/include/c++/ios \
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwchar \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h \
/usr/include/sys/_null.h /usr/include/machine/_limits.h \
/usr/include/_ctype.h /usr/include/runetype.h /usr/include/stdint.h \
/usr/include/machine/_stdint.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/cstdio \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/clocale /usr/include/locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/cctype /usr/include/ctype.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h \
/usr/include/pthread.h /usr/include/sys/_pthreadtypes.h \
/usr/include/sys/_sigset.h /usr/include/sched.h /usr/include/time.h \
/usr/include/sys/timespec.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h \
/usr/include/machine/endian.h /usr/include/sys/select.h \
/usr/include/sys/_timeval.h /usr/include/sys/unistd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h \
/usr/local/lib/gcc-4.3.4/include/c++/string \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h \
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h \
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/streambuf \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwctype /usr/include/wctype.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/ostream \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc include/ffms.h \
src/core/matroskaparser.h src/core/stdiostream.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h \
/usr/include/string.h /usr/include/strings.h \
/usr/local/include/libavformat/avformat.h \
/usr/local/include/libavcodec/avcodec.h /usr/include/errno.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/common.h /usr/include/inttypes.h \
/usr/include/machine/_inttypes.h /usr/include/sys/stdint.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h \
/usr/include/limits.h /usr/include/sys/limits.h \
/usr/include/sys/syslimits.h /usr/include/math.h \
/usr/local/include/libavutil/mem.h \
/usr/local/include/libavutil/mathematics.h \
/usr/local/include/libavutil/rational.h \
/usr/local/include/libavutil/intfloat_readwrite.h \
/usr/local/include/libavutil/log.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/pixfmt.h \
/usr/local/include/libavformat/avio.h \
/usr/local/include/libavutil/common.h \
/usr/local/include/libswscale/swscale.h \
/usr/local/include/libpostproc/postprocess.h include/ffmscompat.h \
src/core/wave64writer.h /usr/local/lib/gcc-4.3.4/include/c++/iostream \
/usr/local/lib/gcc-4.3.4/include/c++/algorithm \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algo.h \
/usr/local/lib/gcc-4.3.4/include/c++/cstdlib \
/usr/local/lib/gcc-4.3.4/include/c++/bits/algorithmfwd.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_heap.h \
/usr/local/include/libavutil/sha1.h
src/core/indexing.h:
/usr/local/lib/gcc-4.3.4/include/c++/memory:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/cstddef:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h:
/usr/include/sys/_types.h:
/usr/include/sys/cdefs.h:
/usr/include/machine/_types.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h:
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/new:
/usr/local/lib/gcc-4.3.4/include/c++/exception:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_tempbuf.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_raw_storage_iter.h:
/usr/local/lib/gcc-4.3.4/include/c++/backward/auto_ptr.h:
src/core/utils.h:
/usr/local/lib/gcc-4.3.4/include/c++/vector:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/fstream:
/usr/local/lib/gcc-4.3.4/include/c++/istream:
/usr/local/lib/gcc-4.3.4/include/c++/ios:
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwchar:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h:
/usr/include/sys/_null.h:
/usr/include/machine/_limits.h:
/usr/include/_ctype.h:
/usr/include/runetype.h:
/usr/include/stdint.h:
/usr/include/machine/_stdint.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/cstdio:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/clocale:
/usr/include/locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/cctype:
/usr/include/ctype.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h:
/usr/include/pthread.h:
/usr/include/sys/_pthreadtypes.h:
/usr/include/sys/_sigset.h:
/usr/include/sched.h:
/usr/include/time.h:
/usr/include/sys/timespec.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h:
/usr/include/machine/endian.h:
/usr/include/sys/select.h:
/usr/include/sys/_timeval.h:
/usr/include/sys/unistd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h:
/usr/local/lib/gcc-4.3.4/include/c++/string:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h:
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h:
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/streambuf:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwctype:
/usr/include/wctype.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/ostream:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc:
include/ffms.h:
src/core/matroskaparser.h:
src/core/stdiostream.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h:
/usr/include/string.h:
/usr/include/strings.h:
/usr/local/include/libavformat/avformat.h:
/usr/local/include/libavcodec/avcodec.h:
/usr/include/errno.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/common.h:
/usr/include/inttypes.h:
/usr/include/machine/_inttypes.h:
/usr/include/sys/stdint.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h:
/usr/include/limits.h:
/usr/include/sys/limits.h:
/usr/include/sys/syslimits.h:
/usr/include/math.h:
/usr/local/include/libavutil/mem.h:
/usr/local/include/libavutil/mathematics.h:
/usr/local/include/libavutil/rational.h:
/usr/local/include/libavutil/intfloat_readwrite.h:
/usr/local/include/libavutil/log.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/pixfmt.h:
/usr/local/include/libavformat/avio.h:
/usr/local/include/libavutil/common.h:
/usr/local/include/libswscale/swscale.h:
/usr/local/include/libpostproc/postprocess.h:
include/ffmscompat.h:
src/core/wave64writer.h:
/usr/local/lib/gcc-4.3.4/include/c++/iostream:
/usr/local/lib/gcc-4.3.4/include/c++/algorithm:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algo.h:
/usr/local/lib/gcc-4.3.4/include/c++/cstdlib:
/usr/local/lib/gcc-4.3.4/include/c++/bits/algorithmfwd.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_heap.h:
/usr/local/include/libavutil/sha1.h:

37
aegisub/libffms/src/core/.deps/matroskaparser.Po Normal file
View file

@ -0,0 +1,37 @@
src/core/matroskaparser.o: src/core/matroskaparser.c \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h \
/usr/include/sys/cdefs.h /usr/include/sys/_null.h \
/usr/include/sys/_types.h /usr/include/machine/_types.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h \
/usr/include/string.h /usr/include/strings.h /usr/include/setjmp.h \
/usr/include/machine/setjmp.h src/core/matroskaparser.h \
/usr/include/zlib.h /usr/include/zconf.h
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h:
/usr/include/sys/cdefs.h:
/usr/include/sys/_null.h:
/usr/include/sys/_types.h:
/usr/include/machine/_types.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h:
/usr/include/string.h:
/usr/include/strings.h:
/usr/include/setjmp.h:
/usr/include/machine/setjmp.h:
src/core/matroskaparser.h:
/usr/include/zlib.h:
/usr/include/zconf.h:

34
aegisub/libffms/src/core/.deps/stdiostream.Po Normal file
View file

@ -0,0 +1,34 @@
src/core/stdiostream.o: src/core/stdiostream.c src/core/stdiostream.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h \
/usr/include/sys/cdefs.h /usr/include/sys/_null.h \
/usr/include/sys/_types.h /usr/include/machine/_types.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h \
/usr/include/string.h /usr/include/strings.h src/core/matroskaparser.h \
include/ffmscompat.h /usr/include/errno.h
src/core/stdiostream.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h:
/usr/include/sys/cdefs.h:
/usr/include/sys/_null.h:
/usr/include/sys/_types.h:
/usr/include/machine/_types.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h:
/usr/include/string.h:
/usr/include/strings.h:
src/core/matroskaparser.h:
include/ffmscompat.h:
/usr/include/errno.h:

397
aegisub/libffms/src/core/.deps/utils.Po Normal file
View file

@ -0,0 +1,397 @@
src/core/utils.o: src/core/utils.cpp /usr/include/string.h \
/usr/include/sys/cdefs.h /usr/include/sys/_null.h \
/usr/include/sys/_types.h /usr/include/machine/_types.h \
/usr/include/strings.h /usr/include/errno.h src/core/utils.h \
/usr/local/lib/gcc-4.3.4/include/c++/vector \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/cstddef \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h \
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/new \
/usr/local/lib/gcc-4.3.4/include/c++/exception \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/fstream \
/usr/local/lib/gcc-4.3.4/include/c++/istream \
/usr/local/lib/gcc-4.3.4/include/c++/ios \
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwchar \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h \
/usr/include/machine/_limits.h /usr/include/_ctype.h \
/usr/include/runetype.h /usr/include/stdint.h \
/usr/include/machine/_stdint.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/cstdio \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/clocale /usr/include/locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/cctype /usr/include/ctype.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h \
/usr/include/pthread.h /usr/include/sys/_pthreadtypes.h \
/usr/include/sys/_sigset.h /usr/include/sched.h /usr/include/time.h \
/usr/include/sys/timespec.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h \
/usr/include/machine/endian.h /usr/include/sys/select.h \
/usr/include/sys/_timeval.h /usr/include/sys/unistd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h \
/usr/local/lib/gcc-4.3.4/include/c++/string \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h \
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h \
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/streambuf \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwctype /usr/include/wctype.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/ostream \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc include/ffms.h \
src/core/matroskaparser.h src/core/stdiostream.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h \
/usr/local/include/libavformat/avformat.h \
/usr/local/include/libavcodec/avcodec.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/common.h /usr/include/inttypes.h \
/usr/include/machine/_inttypes.h /usr/include/sys/stdint.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h \
/usr/include/limits.h /usr/include/sys/limits.h \
/usr/include/sys/syslimits.h /usr/include/math.h \
/usr/local/include/libavutil/mem.h \
/usr/local/include/libavutil/mathematics.h \
/usr/local/include/libavutil/rational.h \
/usr/local/include/libavutil/intfloat_readwrite.h \
/usr/local/include/libavutil/log.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/pixfmt.h \
/usr/local/include/libavformat/avio.h \
/usr/local/include/libavutil/common.h \
/usr/local/include/libswscale/swscale.h \
/usr/local/include/libpostproc/postprocess.h include/ffmscompat.h \
src/core/indexing.h /usr/local/lib/gcc-4.3.4/include/c++/memory \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_tempbuf.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_raw_storage_iter.h \
/usr/local/lib/gcc-4.3.4/include/c++/backward/auto_ptr.h \
src/core/wave64writer.h /usr/local/lib/gcc-4.3.4/include/c++/iostream
/usr/include/string.h:
/usr/include/sys/cdefs.h:
/usr/include/sys/_null.h:
/usr/include/sys/_types.h:
/usr/include/machine/_types.h:
/usr/include/strings.h:
/usr/include/errno.h:
src/core/utils.h:
/usr/local/lib/gcc-4.3.4/include/c++/vector:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/cstddef:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h:
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/new:
/usr/local/lib/gcc-4.3.4/include/c++/exception:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/fstream:
/usr/local/lib/gcc-4.3.4/include/c++/istream:
/usr/local/lib/gcc-4.3.4/include/c++/ios:
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwchar:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h:
/usr/include/machine/_limits.h:
/usr/include/_ctype.h:
/usr/include/runetype.h:
/usr/include/stdint.h:
/usr/include/machine/_stdint.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/cstdio:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/clocale:
/usr/include/locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/cctype:
/usr/include/ctype.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h:
/usr/include/pthread.h:
/usr/include/sys/_pthreadtypes.h:
/usr/include/sys/_sigset.h:
/usr/include/sched.h:
/usr/include/time.h:
/usr/include/sys/timespec.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h:
/usr/include/machine/endian.h:
/usr/include/sys/select.h:
/usr/include/sys/_timeval.h:
/usr/include/sys/unistd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h:
/usr/local/lib/gcc-4.3.4/include/c++/string:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h:
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h:
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/streambuf:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwctype:
/usr/include/wctype.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/ostream:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc:
include/ffms.h:
src/core/matroskaparser.h:
src/core/stdiostream.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h:
/usr/local/include/libavformat/avformat.h:
/usr/local/include/libavcodec/avcodec.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/common.h:
/usr/include/inttypes.h:
/usr/include/machine/_inttypes.h:
/usr/include/sys/stdint.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h:
/usr/include/limits.h:
/usr/include/sys/limits.h:
/usr/include/sys/syslimits.h:
/usr/include/math.h:
/usr/local/include/libavutil/mem.h:
/usr/local/include/libavutil/mathematics.h:
/usr/local/include/libavutil/rational.h:
/usr/local/include/libavutil/intfloat_readwrite.h:
/usr/local/include/libavutil/log.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/pixfmt.h:
/usr/local/include/libavformat/avio.h:
/usr/local/include/libavutil/common.h:
/usr/local/include/libswscale/swscale.h:
/usr/local/include/libpostproc/postprocess.h:
include/ffmscompat.h:
src/core/indexing.h:
/usr/local/lib/gcc-4.3.4/include/c++/memory:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_tempbuf.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_raw_storage_iter.h:
/usr/local/lib/gcc-4.3.4/include/c++/backward/auto_ptr.h:
src/core/wave64writer.h:
/usr/local/lib/gcc-4.3.4/include/c++/iostream:

383
aegisub/libffms/src/core/.deps/wave64writer.Po Normal file
View file

@ -0,0 +1,383 @@
src/core/wave64writer.o: src/core/wave64writer.cpp \
src/core/wave64writer.h /usr/include/stdint.h /usr/include/sys/cdefs.h \
/usr/include/sys/_types.h /usr/include/machine/_types.h \
/usr/include/machine/_stdint.h \
/usr/local/lib/gcc-4.3.4/include/c++/iostream \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/ostream \
/usr/local/lib/gcc-4.3.4/include/c++/ios \
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwchar \
/usr/local/lib/gcc-4.3.4/include/c++/cstddef \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h \
/usr/include/sys/_null.h /usr/include/machine/_limits.h \
/usr/include/_ctype.h /usr/include/runetype.h \
/usr/local/lib/gcc-4.3.4/include/c++/exception \
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h \
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h \
/usr/local/lib/gcc-4.3.4/include/c++/cstdio \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/clocale /usr/include/locale.h \
/usr/local/lib/gcc-4.3.4/include/c++/cctype /usr/include/ctype.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h \
/usr/include/pthread.h /usr/include/sys/_pthreadtypes.h \
/usr/include/sys/_sigset.h /usr/include/sched.h /usr/include/time.h \
/usr/include/sys/timespec.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h \
/usr/include/machine/endian.h /usr/include/sys/select.h \
/usr/include/sys/_timeval.h /usr/include/sys/unistd.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h \
/usr/local/lib/gcc-4.3.4/include/c++/string \
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h \
/usr/local/lib/gcc-4.3.4/include/c++/new \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h \
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h \
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/streambuf \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h \
/usr/local/lib/gcc-4.3.4/include/c++/cwctype /usr/include/wctype.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/istream \
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc \
/usr/local/lib/gcc-4.3.4/include/c++/fstream \
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h \
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc src/core/utils.h \
/usr/local/lib/gcc-4.3.4/include/c++/vector \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h \
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc include/ffms.h \
src/core/matroskaparser.h src/core/stdiostream.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h \
/usr/include/string.h /usr/include/strings.h \
/usr/local/include/libavformat/avformat.h \
/usr/local/include/libavcodec/avcodec.h /usr/include/errno.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/common.h /usr/include/inttypes.h \
/usr/include/machine/_inttypes.h /usr/include/sys/stdint.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h \
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h \
/usr/include/limits.h /usr/include/sys/limits.h \
/usr/include/sys/syslimits.h /usr/include/math.h \
/usr/local/include/libavutil/mem.h \
/usr/local/include/libavutil/mathematics.h \
/usr/local/include/libavutil/rational.h \
/usr/local/include/libavutil/intfloat_readwrite.h \
/usr/local/include/libavutil/log.h \
/usr/local/include/libavutil/avutil.h \
/usr/local/include/libavutil/pixfmt.h \
/usr/local/include/libavformat/avio.h \
/usr/local/include/libavutil/common.h \
/usr/local/include/libswscale/swscale.h \
/usr/local/include/libpostproc/postprocess.h include/ffmscompat.h
src/core/wave64writer.h:
/usr/include/stdint.h:
/usr/include/sys/cdefs.h:
/usr/include/sys/_types.h:
/usr/include/machine/_types.h:
/usr/include/machine/_stdint.h:
/usr/local/lib/gcc-4.3.4/include/c++/iostream:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++config.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/os_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/cpu_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/ostream:
/usr/local/lib/gcc-4.3.4/include/c++/ios:
/usr/local/lib/gcc-4.3.4/include/c++/iosfwd:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stringfwd.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/postypes.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwchar:
/usr/local/lib/gcc-4.3.4/include/c++/cstddef:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stddef.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/wchar.h:
/usr/include/sys/_null.h:
/usr/include/machine/_limits.h:
/usr/include/_ctype.h:
/usr/include/runetype.h:
/usr/local/lib/gcc-4.3.4/include/c++/exception:
/usr/local/lib/gcc-4.3.4/include/c++/bits/char_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_algobase.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/functexcept.h:
/usr/local/lib/gcc-4.3.4/include/c++/exception_defines.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/cpp_type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/type_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/numeric_traits.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_pair.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_move.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/concept_check.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_types.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator_base_funcs.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++/debug/debug.h:
/usr/local/lib/gcc-4.3.4/include/c++/cstdio:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdio.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include/stdarg.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/localefwd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/clocale:
/usr/include/locale.h:
/usr/local/lib/gcc-4.3.4/include/c++/cctype:
/usr/include/ctype.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ios_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/atomicity.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/gthr-default.h:
/usr/include/pthread.h:
/usr/include/sys/_pthreadtypes.h:
/usr/include/sys/_sigset.h:
/usr/include/sched.h:
/usr/include/time.h:
/usr/include/sys/timespec.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/unistd.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/sys/types.h:
/usr/include/machine/endian.h:
/usr/include/sys/select.h:
/usr/include/sys/_timeval.h:
/usr/include/sys/unistd.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/atomic_word.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.h:
/usr/local/lib/gcc-4.3.4/include/c++/string:
/usr/local/lib/gcc-4.3.4/include/c++/bits/allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/ext/new_allocator.h:
/usr/local/lib/gcc-4.3.4/include/c++/new:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream_insert.h:
/usr/local/lib/gcc-4.3.4/include/c++/cxxabi-forced.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_function.h:
/usr/local/lib/gcc-4.3.4/include/c++/backward/binders.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_string.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_classes.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/streambuf:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.h:
/usr/local/lib/gcc-4.3.4/include/c++/cwctype:
/usr/include/wctype.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_base.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/streambuf_iterator.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/ctype_inline.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/locale_facets.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/basic_ios.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/bits/ostream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/istream:
/usr/local/lib/gcc-4.3.4/include/c++/bits/istream.tcc:
/usr/local/lib/gcc-4.3.4/include/c++/fstream:
/usr/local/lib/gcc-4.3.4/include/c++/bits/codecvt.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/basic_file.h:
/usr/local/lib/gcc-4.3.4/include/c++//i386-portbld-freebsd8.0/bits/c++io.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/fstream.tcc:
src/core/utils.h:
/usr/local/lib/gcc-4.3.4/include/c++/vector:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_construct.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_uninitialized.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_vector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/stl_bvector.h:
/usr/local/lib/gcc-4.3.4/include/c++/bits/vector.tcc:
include/ffms.h:
src/core/matroskaparser.h:
src/core/stdiostream.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/stdlib.h:
/usr/include/string.h:
/usr/include/strings.h:
/usr/local/include/libavformat/avformat.h:
/usr/local/include/libavcodec/avcodec.h:
/usr/include/errno.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/common.h:
/usr/include/inttypes.h:
/usr/include/machine/_inttypes.h:
/usr/include/sys/stdint.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/limits.h:
/usr/local/lib/gcc-4.3.4/gcc/i386-portbld-freebsd8.0/4.3.4/include-fixed/syslimits.h:
/usr/include/limits.h:
/usr/include/sys/limits.h:
/usr/include/sys/syslimits.h:
/usr/include/math.h:
/usr/local/include/libavutil/mem.h:
/usr/local/include/libavutil/mathematics.h:
/usr/local/include/libavutil/rational.h:
/usr/local/include/libavutil/intfloat_readwrite.h:
/usr/local/include/libavutil/log.h:
/usr/local/include/libavutil/avutil.h:
/usr/local/include/libavutil/pixfmt.h:
/usr/local/include/libavformat/avio.h:
/usr/local/include/libavutil/common.h:
/usr/local/include/libswscale/swscale.h:
/usr/local/include/libpostproc/postprocess.h:
include/ffmscompat.h:

0
aegisub/libffms/src/core/.dirstamp Normal file
View file

0
aegisub/libffms/coparser.h → aegisub/libffms/src/core/coparser.h
View file

107
aegisub/libffms/src/core/ffaudiosource.cpp Normal file
View file

@ -0,0 +1,107 @@
// Copyright (c) 2007-2009 Fredrik Mellbin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include "ffaudiosource.h"
/* Audio Cache */
TAudioBlock::TAudioBlock(int64_t Start, int64_t Samples, uint8_t *SrcData, size_t SrcBytes) {
this->Start = Start;
this->Samples = Samples;
Data = new uint8_t[SrcBytes];
memcpy(Data, SrcData, SrcBytes);
}
TAudioBlock::~TAudioBlock() {
delete[] Data;
}
TAudioCache::TAudioCache() {
MaxCacheBlocks = 0;
BytesPerSample = 0;
}
TAudioCache::~TAudioCache() {
for (TAudioCache::iterator it=begin(); it != end(); it++)
delete *it;
}
void TAudioCache::Initialize(int BytesPerSample, int MaxCacheBlocks) {
this->BytesPerSample = BytesPerSample;
this->MaxCacheBlocks = MaxCacheBlocks;
}
void TAudioCache::CacheBlock(int64_t Start, int64_t Samples, uint8_t *SrcData) {
if (BytesPerSample > 0) {
for (TAudioCache::iterator it=begin(); it != end(); it++) {
if ((*it)->Start == Start) {
delete *it;
erase(it);
break;
}
}
push_front(new TAudioBlock(Start, Samples, SrcData, static_cast<size_t>(Samples * BytesPerSample)));
if (static_cast<int>(size()) >= MaxCacheBlocks) {
delete back();
pop_back();
}
}
}
bool TAudioCache::AudioBlockComp(TAudioBlock *A, TAudioBlock *B) {
return A->Start < B->Start;
}
int64_t TAudioCache::FillRequest(int64_t Start, int64_t Samples, uint8_t *Dst) {
// May be better to move used blocks to the front
std::list<TAudioBlock *> UsedBlocks;
for (TAudioCache::iterator it=begin(); it != end(); it++) {
int64_t SrcOffset = FFMAX(0, Start - (*it)->Start);
int64_t DstOffset = FFMAX(0, (*it)->Start - Start);
int64_t CopySamples = FFMIN((*it)->Samples - SrcOffset, Samples - DstOffset);
if (CopySamples > 0) {
memcpy(Dst + DstOffset * BytesPerSample, (*it)->Data + SrcOffset * BytesPerSample, static_cast<size_t>(CopySamples * BytesPerSample));
UsedBlocks.push_back(*it);
}
}
UsedBlocks.sort(AudioBlockComp);
int64_t Ret = Start;
for (std::list<TAudioBlock *>::iterator it = UsedBlocks.begin(); it != UsedBlocks.end(); it++) {
if (it == UsedBlocks.begin() || Ret == (*it)->Start)
Ret = (*it)->Start + (*it)->Samples;
else
break;
}
return FFMIN(Ret, Start + Samples);
}
/* FFAudio base class */
FFAudio::FFAudio(const char *SourceFile, FFIndex *Index, char *ErrorMsg, unsigned MsgSize) : DecodingBuffer(AVCODEC_MAX_AUDIO_FRAME_SIZE * 10) {
if (Index->CompareFileSignature(SourceFile, ErrorMsg, MsgSize))
throw ErrorMsg;
CurrentSample = 0;
}
FFAudio::~FFAudio() {
}

13
aegisub/libffms/ffaudiosource.h → aegisub/libffms/src/core/ffaudiosource.h
View file

@ -34,13 +34,14 @@ extern "C" {
#include "ffms.h"
#ifdef HAALISOURCE
# define WIN32_LEAN_AND_MEAN
# define _WIN32_DCOM
# include <windows.h>
# include <tchar.h>
# include <atlbase.h>
# include <dshow.h>
# include "CoParser.h"
# include <initguid.h>
# include "CoParser.h"
# include "guids.h"
#endif
@ -71,16 +72,16 @@ class FFAudio {
protected:
TAudioCache AudioCache;
int64_t CurrentSample;
uint8_t *DecodingBuffer;
std::vector<uint8_t> DecodingBuffer;
FFTrack Frames;
AVCodecContext *CodecContext;
int AudioTrack;
TAudioProperties AP;
FFAudioProperties AP;
public:
FFAudio();
FFAudio(const char *SourceFile, FFIndex *Index, char *ErrorMsg, unsigned MsgSize);
virtual ~FFAudio();
FFTrack *GetFFTrack() { return &Frames; }
const TAudioProperties& GetTAudioProperties() { return AP; }
const FFAudioProperties& GetFFAudioProperties() { return AP; }
virtual int GetAudio(void *Buf, int64_t Start, int64_t Count, char *ErrorMsg, unsigned MsgSize) = 0;
};
@ -116,7 +117,7 @@ public:
class FFHaaliAudio : public FFAudio {
private:
CComPtr<IMMContainer> pMMC;
uint8_t * CodecPrivate;
std::vector<uint8_t> CodecPrivate;
void Free(bool CloseCodec);
int DecodeNextAudioBlock(int64_t *AFirstStartTime, int64_t *Count, char *ErrorMsg, unsigned MsgSize);

264
aegisub/libffms/src/core/ffhaaliaudio.cpp Normal file
View file

@ -0,0 +1,264 @@
// Copyright (c) 2007-2009 Fredrik Mellbin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#ifdef HAALISOURCE
#include "ffaudiosource.h"
void FFHaaliAudio::Free(bool CloseCodec) {
if (CloseCodec)
avcodec_close(CodecContext);
av_freep(&CodecContext);
}
int FFHaaliAudio::DecodeNextAudioBlock(int64_t *AFirstStartTime, int64_t *Count, char *ErrorMsg, unsigned MsgSize) {
const size_t SizeConst = (av_get_bits_per_sample_format(CodecContext->sample_fmt) * CodecContext->channels) / 8;
int Ret = -1;
*AFirstStartTime = -1;
*Count = 0;
uint8_t *Buf = &DecodingBuffer[0];
AVPacket Packet;
InitNullPacket(&Packet);
for (;;) {
CComPtr<IMMFrame> pMMF;
if (pMMC->ReadFrame(NULL, &pMMF) != S_OK)
break;
REFERENCE_TIME Ts, Te;
if (*AFirstStartTime < 0 && SUCCEEDED(pMMF->GetTime(&Ts, &Te)))
*AFirstStartTime = Ts;
if (pMMF->GetTrack() == AudioTrack) {
BYTE *Data = NULL;
if (FAILED(pMMF->GetPointer(&Data)))
goto Done;
Packet.data = Data;
Packet.size = pMMF->GetActualDataLength();
if (pMMF->IsSyncPoint() == S_OK)
Packet.flags = AV_PKT_FLAG_KEY;
else
Packet.flags = 0;
while (Packet.size > 0) {
int TempOutputBufSize = AVCODEC_MAX_AUDIO_FRAME_SIZE * 10;
Ret = avcodec_decode_audio3(CodecContext, (int16_t *)Buf, &TempOutputBufSize, &Packet);
if (Ret < 0) {// throw error or something?
goto Done;
}
if (Ret > 0) {
Packet.size -= Ret;
Packet.data += Ret;
Buf += TempOutputBufSize;
if (SizeConst)
*Count += TempOutputBufSize / SizeConst;
}
}
goto Done;
}
}
Done:
return Ret;
}
FFHaaliAudio::FFHaaliAudio(const char *SourceFile, int Track, FFIndex *Index,
int SourceMode, char *ErrorMsg, unsigned MsgSize)
: FFAudio(SourceFile, Index, ErrorMsg, MsgSize) {
AVCodec *Codec = NULL;
CodecContext = NULL;
AudioTrack = Track;
Frames = (*Index)[AudioTrack];
if (Frames.size() == 0) {
snprintf(ErrorMsg, MsgSize, "Audio track contains no frames, was it indexed properly?");
throw ErrorMsg;
}
CLSID clsid = HAALI_TS_Parser;
if (SourceMode == 1)
clsid = HAALI_OGM_Parser;
if (FAILED(pMMC.CoCreateInstance(clsid))) {
snprintf(ErrorMsg, MsgSize, "Can't create parser");
throw ErrorMsg;
}
CComPtr<IMemAlloc> pMA;
if (FAILED(pMA.CoCreateInstance(CLSID_MemAlloc))) {
snprintf(ErrorMsg, MsgSize, "Can't create memory allocator");
throw ErrorMsg;
}
CComPtr<IMMStream> pMS;
if (FAILED(pMS.CoCreateInstance(CLSID_DiskFile))) {
snprintf(ErrorMsg, MsgSize, "Can't create disk file reader");
throw ErrorMsg;
}
WCHAR WSourceFile[2048];
ffms_mbstowcs(WSourceFile, SourceFile, 2000);
CComQIPtr<IMMStreamOpen> pMSO(pMS);
if (FAILED(pMSO->Open(WSourceFile))) {
snprintf(ErrorMsg, MsgSize, "Can't open file");
throw ErrorMsg;
}
if (FAILED(pMMC->Open(pMS, 0, NULL, pMA))) {
snprintf(ErrorMsg, MsgSize, "Can't parse file");
throw ErrorMsg;
}
int CodecPrivateSize = 0;
int CurrentTrack = 0;
CComPtr<IEnumUnknown> pEU;
CComQIPtr<IPropertyBag> pBag;
if (SUCCEEDED(pMMC->EnumTracks(&pEU))) {
CComPtr<IUnknown> pU;
while (pEU->Next(1, &pU, NULL) == S_OK) {
if (CurrentTrack++ == Track) {
pBag = pU;
if (pBag) {
CComVariant pV;
pV.Clear();
if (SUCCEEDED(pBag->Read(L"CodecPrivate", &pV, NULL))) {
CodecPrivateSize = vtSize(pV);
CodecPrivate.resize(CodecPrivateSize);
vtCopy(pV, FFMS_GET_VECTOR_PTR(CodecPrivate));
}
pV.Clear();
if (SUCCEEDED(pBag->Read(L"CodecID", &pV, NULL)) && SUCCEEDED(pV.ChangeType(VT_BSTR))) {
char ACodecID[2048];
wcstombs(ACodecID, pV.bstrVal, 2000);
Codec = avcodec_find_decoder(MatroskaToFFCodecID(ACodecID, FFMS_GET_VECTOR_PTR(CodecPrivate)));
}
}
}
pU = NULL;
}
}
CodecContext = avcodec_alloc_context();
CodecContext->extradata = FFMS_GET_VECTOR_PTR(CodecPrivate);
CodecContext->extradata_size = CodecPrivateSize;
if (Codec == NULL) {
Free(false);
snprintf(ErrorMsg, MsgSize, "Audio codec not found");
throw ErrorMsg;
}
InitializeCodecContextFromHaaliInfo(pBag, CodecContext);
if (avcodec_open(CodecContext, Codec) < 0) {
Free(false);
snprintf(ErrorMsg, MsgSize, "Could not open audio codec");
throw ErrorMsg;
}
// Always try to decode a frame to make sure all required parameters are known
int64_t Dummy1, Dummy2;
if (DecodeNextAudioBlock(&Dummy1, &Dummy2, ErrorMsg, MsgSize) < 0) {
Free(true);
throw ErrorMsg;
}
pMMC->Seek(Frames[0].DTS, MKVF_SEEK_TO_PREV_KEYFRAME_STRICT);
avcodec_flush_buffers(CodecContext);
FillAP(AP, CodecContext, Frames);
if (AP.SampleRate <= 0 || AP.BitsPerSample <= 0) {
Free(true);
snprintf(ErrorMsg, MsgSize, "Codec returned zero size audio");
throw ErrorMsg;
}
AudioCache.Initialize((AP.Channels * AP.BitsPerSample) / 8, 50);
}
FFHaaliAudio::~FFHaaliAudio() {
Free(true);
}
int FFHaaliAudio::GetAudio(void *Buf, int64_t Start, int64_t Count, char *ErrorMsg, unsigned MsgSize) {
const int64_t SizeConst = (av_get_bits_per_sample_format(CodecContext->sample_fmt) * CodecContext->channels) / 8;
memset(Buf, 0, static_cast<size_t>(SizeConst * Count));
bool HasSeeked = false;
int PreDecBlocks = 0;
uint8_t *DstBuf = static_cast<uint8_t *>(Buf);
// Fill with everything in the cache
int64_t CacheEnd = AudioCache.FillRequest(Start, Count, DstBuf);
// Was everything in the cache?
if (CacheEnd == Start + Count)
return 0;
int CurrentAudioBlock;
// Is seeking required to decode the requested samples?
// if (!(CurrentSample >= Start && CurrentSample <= CacheEnd)) {
if (CurrentSample != CacheEnd) {
PreDecBlocks = 15;
CurrentAudioBlock = FFMAX((int64_t)Frames.FindClosestAudioKeyFrame(CacheEnd) - PreDecBlocks - 20, (int64_t)0);
pMMC->Seek(Frames[CurrentAudioBlock].DTS, MKVF_SEEK_TO_PREV_KEYFRAME_STRICT);
avcodec_flush_buffers(CodecContext);
HasSeeked = true;
} else {
CurrentAudioBlock = Frames.FindClosestAudioKeyFrame(CurrentSample);
}
int64_t FirstTime, DecodeCount;
do {
int Ret = DecodeNextAudioBlock(&FirstTime, &DecodeCount, ErrorMsg, MsgSize);
if (Ret < 0) {
// FIXME
//Env->ThrowError("Bleh, bad audio decoding");
}
if (HasSeeked) {
CurrentAudioBlock = Frames.ClosestFrameFromDTS(FirstTime);
HasSeeked = false;
}
// Cache the block if enough blocks before it have been decoded to avoid garbage
if (PreDecBlocks == 0) {
AudioCache.CacheBlock(Frames[CurrentAudioBlock].SampleStart, DecodeCount, &DecodingBuffer[0]);
CacheEnd = AudioCache.FillRequest(CacheEnd, Start + Count - CacheEnd, DstBuf + (CacheEnd - Start) * SizeConst);
} else {
PreDecBlocks--;
}
CurrentAudioBlock++;
if (CurrentAudioBlock < static_cast<int>(Frames.size()))
CurrentSample = Frames[CurrentAudioBlock].SampleStart;
} while (Start + Count - CacheEnd > 0 && CurrentAudioBlock < static_cast<int>(Frames.size()));
return 0;
}
#endif // HAALISOURCE

271
aegisub/libffms/src/core/ffhaaliindexer.cpp Normal file
View file

@ -0,0 +1,271 @@
// Copyright (c) 2007-2009 Fredrik Mellbin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#ifdef HAALISOURCE
#include "indexing.h"
FFHaaliIndexer::FFHaaliIndexer(const char *Filename, int SourceMode, char *ErrorMsg, unsigned MsgSize) : FFIndexer(Filename, ErrorMsg, MsgSize) {
SourceFile = Filename;
this->SourceMode = SourceMode;
memset(TrackType, FFMS_TYPE_UNKNOWN, sizeof(TrackType));
memset(Codec, 0, sizeof(Codec));
memset(CodecPrivate, 0, sizeof(CodecPrivate));
memset(CodecPrivateSize, 0, sizeof(CodecPrivateSize));
Duration = 0;
CLSID clsid = HAALI_TS_Parser;
if (SourceMode == 1)
clsid = HAALI_OGM_Parser;
if (FAILED(pMMC.CoCreateInstance(clsid))) {
snprintf(ErrorMsg, MsgSize, "Can't create parser");
throw ErrorMsg;
}
CComPtr<IMemAlloc> pMA;
if (FAILED(pMA.CoCreateInstance(CLSID_MemAlloc))) {
snprintf(ErrorMsg, MsgSize, "Can't create memory allocator");
throw ErrorMsg;
}
CComPtr<IMMStream> pMS;
if (FAILED(pMS.CoCreateInstance(CLSID_DiskFile))) {
snprintf(ErrorMsg, MsgSize, "Can't create disk file reader");
throw ErrorMsg;
}
WCHAR WSourceFile[2048];
ffms_mbstowcs(WSourceFile, SourceFile, 2000);
CComQIPtr<IMMStreamOpen> pMSO(pMS);
if (FAILED(pMSO->Open(WSourceFile))) {
snprintf(ErrorMsg, MsgSize, "Can't open file");
throw ErrorMsg;
}
if (FAILED(pMMC->Open(pMS, 0, NULL, pMA))) {
if (SourceMode == 0)
snprintf(ErrorMsg, MsgSize, "Can't parse file, most likely a transport stream not cut at packet boundaries");
else if (SourceMode == 1)
snprintf(ErrorMsg, MsgSize, "Can't parse file");
throw ErrorMsg;
}
CComQIPtr<IPropertyBag> pBag2 = pMMC;
CComVariant pV2;
if (SUCCEEDED(pBag2->Read(L"Duration", &pV2, NULL)) && SUCCEEDED(pV2.ChangeType(VT_UI8)))
Duration = pV2.ullVal;
NumTracks = 0;
CComPtr<IEnumUnknown> pEU;
if (SUCCEEDED(pMMC->EnumTracks(&pEU))) {
CComPtr<IUnknown> pU;
while (pEU->Next(1, &pU, NULL) == S_OK) {
CComQIPtr<IPropertyBag> pBag = pU;
PropertyBags[NumTracks] = pBag;
if (pBag) {
CComVariant pV;
unsigned int FourCC = 0;
pV.Clear();
if (SUCCEEDED(pBag->Read(L"Type", &pV, NULL)) && SUCCEEDED(pV.ChangeType(VT_UI4)))
TrackType[NumTracks] = HaaliTrackTypeToFFTrackType(pV.uintVal);
pV.Clear();
if (SUCCEEDED(pBag->Read(L"CodecPrivate", &pV, NULL))) {
CodecPrivateSize[NumTracks] = vtSize(pV);
CodecPrivate[NumTracks].resize(CodecPrivateSize[NumTracks]);
vtCopy(pV, FFMS_GET_VECTOR_PTR(CodecPrivate[NumTracks]));
}
pV.Clear();
if (SUCCEEDED(pBag->Read(L"FOURCC", &pV, NULL)) && SUCCEEDED(pV.ChangeType(VT_UI4)))
FourCC = pV.uintVal;
pV.Clear();
if (SUCCEEDED(pBag->Read(L"CodecID", &pV, NULL)) && SUCCEEDED(pV.ChangeType(VT_BSTR))) {
char CodecID[2048];
wcstombs(CodecID, pV.bstrVal, 2000);
Codec[NumTracks] = avcodec_find_decoder(MatroskaToFFCodecID(CodecID, FFMS_GET_VECTOR_PTR(CodecPrivate[NumTracks]), FourCC));
}
}
pU = NULL;
NumTracks++;
}
}
}
FFIndex *FFHaaliIndexer::DoIndexing(char *ErrorMsg, unsigned MsgSize) {
std::vector<SharedAudioContext> AudioContexts(NumTracks, SharedAudioContext(true));
std::vector<SharedVideoContext> VideoContexts(NumTracks, SharedVideoContext(true));
std::auto_ptr<FFIndex> TrackIndices(new FFIndex(Filesize, Digest));
TrackIndices->Decoder = 2;
if (SourceMode == 1)
TrackIndices->Decoder = 3;
for (int i = 0; i < NumTracks; i++) {
TrackIndices->push_back(FFTrack(1, 1000000, TrackType[i]));
if (TrackType[i] == FFMS_TYPE_VIDEO && Codec[i] && (VideoContexts[i].Parser = av_parser_init(Codec[i]->id))) {
AVCodecContext *CodecContext = avcodec_alloc_context();
CodecContext->extradata = FFMS_GET_VECTOR_PTR(CodecPrivate[i]);
CodecContext->extradata_size = CodecPrivateSize[i];
InitializeCodecContextFromHaaliInfo(PropertyBags[i], CodecContext);
if (avcodec_open(CodecContext, Codec[i]) < 0) {
av_freep(&CodecContext);
snprintf(ErrorMsg, MsgSize, "Could not open video codec");
return NULL;
}
VideoContexts[i].CodecContext = CodecContext;
VideoContexts[i].Parser->flags = PARSER_FLAG_COMPLETE_FRAMES;
}
if (IndexMask & (1 << i) && TrackType[i] == FFMS_TYPE_AUDIO) {
if (Codec[i] == NULL) {
snprintf(ErrorMsg, MsgSize, "Audio codec not found");
return NULL;
}
AVCodecContext *CodecContext = avcodec_alloc_context();
CodecContext->extradata = FFMS_GET_VECTOR_PTR(CodecPrivate[i]);
CodecContext->extradata_size = CodecPrivateSize[i];
AudioContexts[i].CodecContext = CodecContext;
if (avcodec_open(CodecContext, Codec[i]) < 0) {
av_freep(&CodecContext);
AudioContexts[i].CodecContext = NULL;
snprintf(ErrorMsg, MsgSize, "Could not open audio codec");
return NULL;
}
} else {
IndexMask &= ~(1 << i);
}
}
//
AVPacket TempPacket;
InitNullPacket(&TempPacket);
for (;;) {
CComPtr<IMMFrame> pMMF;
if (pMMC->ReadFrame(NULL, &pMMF) != S_OK)
break;
REFERENCE_TIME Ts, Te;
HRESULT hr = pMMF->GetTime(&Ts, &Te);
if (IC) {
if (Duration > 0) {
if (SUCCEEDED(hr)) {
if ((*IC)(Ts, Duration, ICPrivate)) {
snprintf(ErrorMsg, MsgSize, "Cancelled by user");
return NULL;
}
}
} else {
if ((*IC)(0, 1, ICPrivate)) {
snprintf(ErrorMsg, MsgSize, "Cancelled by user");
return NULL;
}
}
}
unsigned int Track = pMMF->GetTrack();
pMMF->GetPointer(&TempPacket.data);
TempPacket.size = pMMF->GetActualDataLength();
// Only create index entries for video for now to save space
if (TrackType[Track] == FFMS_TYPE_VIDEO) {
uint8_t *OB;
int OBSize;
int RepeatPict = -1;
if (VideoContexts[Track].Parser) {
av_parser_parse2(VideoContexts[Track].Parser, VideoContexts[Track].CodecContext, &OB, &OBSize, TempPacket.data, TempPacket.size, ffms_av_nopts_value, ffms_av_nopts_value, ffms_av_nopts_value);
RepeatPict = VideoContexts[Track].Parser->repeat_pict;
}
(*TrackIndices)[Track].push_back(TFrameInfo::VideoFrameInfo(Ts, RepeatPict, pMMF->IsSyncPoint() == S_OK));
} else if (TrackType[Track] == FFMS_TYPE_AUDIO && (IndexMask & (1 << Track))) {
(*TrackIndices)[Track].push_back(TFrameInfo::AudioFrameInfo(Ts, AudioContexts[Track].CurrentSample, pMMF->IsSyncPoint() == S_OK));
AVCodecContext *AudioCodecContext = AudioContexts[Track].CodecContext;
if (pMMF->IsSyncPoint() == S_OK)
TempPacket.flags = AV_PKT_FLAG_KEY;
else
TempPacket.flags = 0;
while (TempPacket.size > 0) {
int dbsize = AVCODEC_MAX_AUDIO_FRAME_SIZE*10;
int Ret = avcodec_decode_audio3(AudioCodecContext, &DecodingBuffer[0], &dbsize, &TempPacket);
if (Ret < 0) {
if (IgnoreDecodeErrors) {
(*TrackIndices)[Track].clear();
IndexMask &= ~(1 << Track);
break;
} else {
snprintf(ErrorMsg, MsgSize, "Audio decoding error");
return NULL;
}
}
if (Ret > 0) {
TempPacket.size -= Ret;
TempPacket.data += Ret;
}
if (dbsize > 0)
AudioContexts[Track].CurrentSample += (dbsize * 8) / (av_get_bits_per_sample_format(AudioCodecContext->sample_fmt) * AudioCodecContext->channels);
if (DumpMask & (1 << Track))
WriteAudio(AudioContexts[Track], TrackIndices.get(), Track, dbsize, ErrorMsg, MsgSize);
}
}
}
TrackIndices->Sort();
return TrackIndices.release();
}
int FFHaaliIndexer::GetNumberOfTracks() {
return NumTracks;
}
FFMS_TrackType FFHaaliIndexer::GetTrackType(int Track) {
return TrackType[Track];
}
const char *FFHaaliIndexer::GetTrackCodec(int Track) {
if (Codec[Track])
return Codec[Track]->long_name;
else
return "Unsupported codec/Unknown codec name";
}
#endif

294
aegisub/libffms/src/core/ffhaalivideo.cpp Normal file
View file

@ -0,0 +1,294 @@
// Copyright (c) 2007-2009 Fredrik Mellbin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include "ffvideosource.h"
#ifdef HAALISOURCE
void FFHaaliVideo::Free(bool CloseCodec) {
if (CloseCodec)
avcodec_close(CodecContext);
av_freep(&CodecContext);
if (BitStreamFilter)
av_bitstream_filter_close(BitStreamFilter);
}
FFHaaliVideo::FFHaaliVideo(const char *SourceFile, int Track,
FFIndex *Index, const char *PP,
int Threads, int SourceMode, char *ErrorMsg, unsigned MsgSize)
: FFVideo(SourceFile, Index, ErrorMsg, MsgSize) {
BitStreamFilter = NULL;
AVCodec *Codec = NULL;
CodecContext = NULL;
VideoTrack = Track;
Frames = (*Index)[VideoTrack];
if (Frames.size() == 0) {
snprintf(ErrorMsg, MsgSize, "Video track contains no frames");
throw ErrorMsg;
}
CLSID clsid = HAALI_TS_Parser;
if (SourceMode == 1)
clsid = HAALI_OGM_Parser;
if (FAILED(pMMC.CoCreateInstance(clsid))) {
snprintf(ErrorMsg, MsgSize, "Can't create parser");
throw ErrorMsg;
}
CComPtr<IMemAlloc> pMA;
if (FAILED(pMA.CoCreateInstance(CLSID_MemAlloc))) {
snprintf(ErrorMsg, MsgSize, "Can't create memory allocator");
throw ErrorMsg;
}
CComPtr<IMMStream> pMS;
if (FAILED(pMS.CoCreateInstance(CLSID_DiskFile))) {
snprintf(ErrorMsg, MsgSize, "Can't create disk file reader");
throw ErrorMsg;
}
WCHAR WSourceFile[2048];
ffms_mbstowcs(WSourceFile, SourceFile, 2000);
CComQIPtr<IMMStreamOpen> pMSO(pMS);
if (FAILED(pMSO->Open(WSourceFile))) {
snprintf(ErrorMsg, MsgSize, "Can't open file");
throw ErrorMsg;
}
if (FAILED(pMMC->Open(pMS, 0, NULL, pMA))) {
snprintf(ErrorMsg, MsgSize, "Can't parse file");
throw ErrorMsg;
}
int CodecPrivateSize = 0;
int CurrentTrack = 0;
CComPtr<IEnumUnknown> pEU;
CComQIPtr<IPropertyBag> pBag;
if (SUCCEEDED(pMMC->EnumTracks(&pEU))) {
CComPtr<IUnknown> pU;
while (pEU->Next(1, &pU, NULL) == S_OK) {
if (CurrentTrack++ == Track) {
pBag = pU;
if (pBag) {
CComVariant pV;
unsigned int FourCC = 0;
pV.Clear();
if (SUCCEEDED(pBag->Read(L"CodecPrivate", &pV, NULL))) {
CodecPrivateSize = vtSize(pV);
CodecPrivate.resize(CodecPrivateSize);
vtCopy(pV, FFMS_GET_VECTOR_PTR(CodecPrivate));
}
pV.Clear();
if (SUCCEEDED(pBag->Read(L"FOURCC", &pV, NULL)) && SUCCEEDED(pV.ChangeType(VT_UI4)))
FourCC = pV.uintVal;
pV.Clear();
if (SUCCEEDED(pBag->Read(L"CodecID", &pV, NULL)) && SUCCEEDED(pV.ChangeType(VT_BSTR))) {
char ACodecID[2048];
wcstombs(ACodecID, pV.bstrVal, 2000);
Codec = avcodec_find_decoder(MatroskaToFFCodecID(ACodecID, FFMS_GET_VECTOR_PTR(CodecPrivate), FourCC));
}
}
}
pU = NULL;
}
}
CodecContext = avcodec_alloc_context();
CodecContext->extradata = FFMS_GET_VECTOR_PTR(CodecPrivate);
CodecContext->extradata_size = CodecPrivateSize;
CodecContext->thread_count = Threads;
if (Codec == NULL) {
Free(false);
snprintf(ErrorMsg, MsgSize, "Video codec not found");
throw ErrorMsg;
}
InitializeCodecContextFromHaaliInfo(pBag, CodecContext);
if (avcodec_open(CodecContext, Codec) < 0) {
Free(false);
snprintf(ErrorMsg, MsgSize, "Could not open video codec");
throw ErrorMsg;
}
if (Codec->id == CODEC_ID_H264 && SourceMode == 0)
BitStreamFilter = av_bitstream_filter_init("h264_mp4toannexb");
// Always try to decode a frame to make sure all required parameters are known
int64_t Dummy;
if (DecodeNextFrame(&Dummy, ErrorMsg, MsgSize)) {
Free(true);
throw ErrorMsg;
}
VP.Width = CodecContext->width;
VP.Height = CodecContext->height;;
VP.FPSDenominator = 1;
VP.FPSNumerator = 30;
VP.RFFDenominator = CodecContext->time_base.num;
VP.RFFNumerator = CodecContext->time_base.den;
VP.NumFrames = Frames.size();
VP.VPixelFormat = CodecContext->pix_fmt;
VP.FirstTime = ((Frames.front().DTS * Frames.TB.Num) / (double)Frames.TB.Den) / 1000;
VP.LastTime = ((Frames.back().DTS * Frames.TB.Num) / (double)Frames.TB.Den) / 1000;
if (VP.Width <= 0 || VP.Height <= 0) {
Free(true);
snprintf(ErrorMsg, MsgSize, "Codec returned zero size video");
throw ErrorMsg;
}
if (InitPP(PP, ErrorMsg, MsgSize)) {
Free(true);
throw ErrorMsg;
}
// Calculate the average framerate
if (Frames.size() >= 2) {
double DTSDiff = (double)(Frames.back().DTS - Frames.front().DTS);
VP.FPSDenominator = (unsigned int)(DTSDiff / (double)1000 / (double)(VP.NumFrames - 1) + 0.5);
VP.FPSNumerator = 1000000;
}
// Output the already decoded frame so it isn't wasted
if (!OutputFrame(DecodeFrame, ErrorMsg, MsgSize)) {
Free(true);
throw ErrorMsg;
}
// Set AR variables
CComVariant pV;
pV.Clear();
if (SUCCEEDED(pBag->Read(L"Video.DisplayWidth", &pV, NULL)) && SUCCEEDED(pV.ChangeType(VT_UI4)))
VP.SARNum = pV.uiVal;
pV.Clear();
if (SUCCEEDED(pBag->Read(L"Video.DisplayHeight", &pV, NULL)) && SUCCEEDED(pV.ChangeType(VT_UI4)))
VP.SARDen = pV.uiVal;
}
FFHaaliVideo::~FFHaaliVideo() {
Free(true);
}
int FFHaaliVideo::DecodeNextFrame(int64_t *AFirstStartTime, char *ErrorMsg, unsigned MsgSize) {
int FrameFinished = 0;
*AFirstStartTime = -1;
AVPacket Packet;
InitNullPacket(&Packet);
for (;;) {
CComPtr<IMMFrame> pMMF;
if (pMMC->ReadFrame(NULL, &pMMF) != S_OK)
break;
REFERENCE_TIME Ts, Te;
if (*AFirstStartTime < 0 && SUCCEEDED(pMMF->GetTime(&Ts, &Te)))
*AFirstStartTime = Ts;
if (pMMF->GetTrack() == VideoTrack) {
BYTE *Data = NULL;
if (FAILED(pMMF->GetPointer(&Data)))
goto Error;
Packet.data = Data;
Packet.size = pMMF->GetActualDataLength();
if (pMMF->IsSyncPoint() == S_OK)
Packet.flags = AV_PKT_FLAG_KEY;
else
Packet.flags = 0;
if (BitStreamFilter)
av_bitstream_filter_filter(BitStreamFilter, CodecContext, NULL,
&Packet.data, &Packet.size, Data, pMMF->GetActualDataLength(), !!Packet.flags);
avcodec_decode_video2(CodecContext, DecodeFrame, &FrameFinished, &Packet);
if (FrameFinished)
goto Done;
}
}
// Flush the last frames
if (CodecContext->has_b_frames) {
AVPacket NullPacket;
InitNullPacket(&NullPacket);
avcodec_decode_video2(CodecContext, DecodeFrame, &FrameFinished, &NullPacket);
}
if (!FrameFinished)
goto Error;
Error:
Done:
return 0;
}
FFAVFrame *FFHaaliVideo::GetFrame(int n, char *ErrorMsg, unsigned MsgSize) {
// PPFrame always holds frame LastFrameNum even if no PP is applied
if (LastFrameNum == n)
return OutputFrame(DecodeFrame, ErrorMsg, MsgSize);
bool HasSeeked = false;
int SeekOffset = 0;
if (n < CurrentFrame || Frames.FindClosestVideoKeyFrame(n) > CurrentFrame + 10) {
ReSeek:
pMMC->Seek(Frames[n + SeekOffset].DTS, MMSF_PREV_KF);
avcodec_flush_buffers(CodecContext);
HasSeeked = true;
}
do {
int64_t StartTime;
if (DecodeNextFrame(&StartTime, ErrorMsg, MsgSize))
return NULL;
if (HasSeeked) {
HasSeeked = false;
if (StartTime < 0 || (CurrentFrame = Frames.FrameFromDTS(StartTime)) < 0) {
// No idea where we are so go back a bit further
if (n + SeekOffset == 0) {
snprintf(ErrorMsg, MsgSize, "Frame accurate seeking is not possible in this file\n");
return NULL;
}
SeekOffset -= FFMIN(20, n + SeekOffset);
goto ReSeek;
}
}
CurrentFrame++;
} while (CurrentFrame <= n);
LastFrameNum = n;
return OutputFrame(DecodeFrame, ErrorMsg, MsgSize);
}
#endif // HAALISOURCE

216
aegisub/libffms/src/core/fflavfaudio.cpp Normal file
View file

@ -0,0 +1,216 @@
// Copyright (c) 2007-2009 Fredrik Mellbin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include "ffaudiosource.h"
void FFLAVFAudio::Free(bool CloseCodec) {
if (CloseCodec)
avcodec_close(CodecContext);
if (FormatContext)
av_close_input_file(FormatContext);
}
FFLAVFAudio::FFLAVFAudio(const char *SourceFile, int Track, FFIndex *Index,
char *ErrorMsg, unsigned MsgSize)
: FFAudio(SourceFile, Index, ErrorMsg, MsgSize){
FormatContext = NULL;
AVCodec *Codec = NULL;
AudioTrack = Track;
Frames = (*Index)[AudioTrack];
if (Frames.size() == 0) {
Free(false);
snprintf(ErrorMsg, MsgSize, "Audio track contains no frames, was it indexed properly?");
throw ErrorMsg;
}
if (av_open_input_file(&FormatContext, SourceFile, NULL, 0, NULL) != 0) {
snprintf(ErrorMsg, MsgSize, "Couldn't open '%s'", SourceFile);
throw ErrorMsg;
}
if (av_find_stream_info(FormatContext) < 0) {
Free(false);
snprintf(ErrorMsg, MsgSize, "Couldn't find stream information");
throw ErrorMsg;
}
CodecContext = FormatContext->streams[AudioTrack]->codec;
Codec = avcodec_find_decoder(CodecContext->codec_id);
if (Codec == NULL) {
Free(false);
snprintf(ErrorMsg, MsgSize, "Audio codec not found");
throw ErrorMsg;
}
if (avcodec_open(CodecContext, Codec) < 0) {
Free(false);
snprintf(ErrorMsg, MsgSize, "Could not open audio codec");
throw ErrorMsg;
}
// Always try to decode a frame to make sure all required parameters are known
int64_t Dummy;
if (DecodeNextAudioBlock(&Dummy, ErrorMsg, MsgSize) < 0) {
Free(true);
throw ErrorMsg;
}
if (av_seek_frame(FormatContext, AudioTrack, Frames[0].DTS, AVSEEK_FLAG_BACKWARD) < 0)
av_seek_frame(FormatContext, AudioTrack, Frames[0].DTS, AVSEEK_FLAG_BACKWARD | AVSEEK_FLAG_ANY);
avcodec_flush_buffers(CodecContext);
FillAP(AP, CodecContext, Frames);
if (AP.SampleRate <= 0 || AP.BitsPerSample <= 0) {
Free(true);
snprintf(ErrorMsg, MsgSize, "Codec returned zero size audio");
throw ErrorMsg;
}
AudioCache.Initialize((AP.Channels * AP.BitsPerSample) / 8, 50);
}
int FFLAVFAudio::DecodeNextAudioBlock(int64_t *Count, char *ErrorMsg, unsigned MsgSize) {
const size_t SizeConst = (av_get_bits_per_sample_format(CodecContext->sample_fmt) * CodecContext->channels) / 8;
int Ret = -1;
*Count = 0;
uint8_t *Buf = &DecodingBuffer[0];
AVPacket Packet, TempPacket;
InitNullPacket(&Packet);
InitNullPacket(&TempPacket);
while (av_read_frame(FormatContext, &Packet) >= 0) {
if (Packet.stream_index == AudioTrack) {
TempPacket.data = Packet.data;
TempPacket.size = Packet.size;
while (TempPacket.size > 0) {
int TempOutputBufSize = AVCODEC_MAX_AUDIO_FRAME_SIZE * 10;
Ret = avcodec_decode_audio3(CodecContext, (int16_t *)Buf, &TempOutputBufSize, &TempPacket);
if (Ret < 0) {// throw error or something?
av_free_packet(&Packet);
goto Done;
}
if (Ret > 0) {
TempPacket.size -= Ret;
TempPacket.data += Ret;
Buf += TempOutputBufSize;
if (SizeConst)
*Count += TempOutputBufSize / SizeConst;
}
}
av_free_packet(&Packet);
goto Done;
}
av_free_packet(&Packet);
}
Done:
return Ret;
}
int FFLAVFAudio::GetAudio(void *Buf, int64_t Start, int64_t Count, char *ErrorMsg, unsigned MsgSize) {
const int64_t SizeConst = (av_get_bits_per_sample_format(CodecContext->sample_fmt) * CodecContext->channels) / 8;
memset(Buf, 0, static_cast<size_t>(SizeConst * Count));
int PreDecBlocks = 0;
uint8_t *DstBuf = static_cast<uint8_t *>(Buf);
// Fill with everything in the cache
int64_t CacheEnd = AudioCache.FillRequest(Start, Count, DstBuf);
// Was everything in the cache?
if (CacheEnd == Start + Count)
return 0;
size_t CurrentAudioBlock;
// Is seeking required to decode the requested samples?
// if (!(CurrentSample >= Start && CurrentSample <= CacheEnd)) {
if (CurrentSample != CacheEnd) {
PreDecBlocks = 15;
CurrentAudioBlock = FFMAX((int64_t)Frames.FindClosestAudioKeyFrame(CacheEnd) - PreDecBlocks - 20, (int64_t)0);
// Did the seeking fail?
if (av_seek_frame(FormatContext, AudioTrack, Frames[CurrentAudioBlock].DTS, AVSEEK_FLAG_BACKWARD) < 0)
av_seek_frame(FormatContext, AudioTrack, Frames[CurrentAudioBlock].DTS, AVSEEK_FLAG_BACKWARD | AVSEEK_FLAG_ANY);
avcodec_flush_buffers(CodecContext);
AVPacket Packet;
InitNullPacket(&Packet);
// Establish where we actually are
// Trigger on packet dts difference since groups can otherwise be indistinguishable
int64_t LastDTS = - 1;
while (av_read_frame(FormatContext, &Packet) >= 0) {
if (Packet.stream_index == AudioTrack) {
if (LastDTS < 0) {
LastDTS = Packet.dts;
} else if (LastDTS != Packet.dts) {
for (size_t i = 0; i < Frames.size(); i++)
if (Frames[i].DTS == Packet.dts) {
// The current match was consumed
CurrentAudioBlock = i + 1;
break;
}
av_free_packet(&Packet);
break;
}
}
av_free_packet(&Packet);
}
} else {
CurrentAudioBlock = Frames.FindClosestAudioKeyFrame(CurrentSample);
}
int64_t DecodeCount;
do {
int Ret = DecodeNextAudioBlock(&DecodeCount, ErrorMsg, MsgSize);
if (Ret < 0) {
// FIXME
//Env->ThrowError("Bleh, bad audio decoding");
}
// Cache the block if enough blocks before it have been decoded to avoid garbage
if (PreDecBlocks == 0) {
AudioCache.CacheBlock(Frames[CurrentAudioBlock].SampleStart, DecodeCount, &DecodingBuffer[0]);
CacheEnd = AudioCache.FillRequest(CacheEnd, Start + Count - CacheEnd, DstBuf + (CacheEnd - Start) * SizeConst);
} else {
PreDecBlocks--;
}
CurrentAudioBlock++;
if (CurrentAudioBlock < Frames.size())
CurrentSample = Frames[CurrentAudioBlock].SampleStart;
} while (Start + Count - CacheEnd > 0 && CurrentAudioBlock < Frames.size());
return 0;
}
FFLAVFAudio::~FFLAVFAudio() {
Free(true);
}

167
aegisub/libffms/src/core/fflavfindexer.cpp Normal file
View file

@ -0,0 +1,167 @@
// Copyright (c) 2007-2009 Fredrik Mellbin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include "indexing.h"
FFLAVFIndexer::FFLAVFIndexer(const char *Filename, AVFormatContext *FormatContext, char *ErrorMsg, unsigned MsgSize) : FFIndexer(Filename, ErrorMsg, MsgSize) {
SourceFile = Filename;
this->FormatContext = FormatContext;
if (av_find_stream_info(FormatContext) < 0) {
av_close_input_file(FormatContext);
snprintf(ErrorMsg, MsgSize, "Couldn't find stream information");
throw ErrorMsg;
}
}
FFLAVFIndexer::~FFLAVFIndexer() {
av_close_input_file(FormatContext);
}
FFIndex *FFLAVFIndexer::DoIndexing(char *ErrorMsg, unsigned MsgSize) {
std::vector<SharedAudioContext> AudioContexts(FormatContext->nb_streams, SharedAudioContext(false));
std::vector<SharedVideoContext> VideoContexts(FormatContext->nb_streams, SharedVideoContext(false));
std::auto_ptr<FFIndex> TrackIndices(new FFIndex(Filesize, Digest));
TrackIndices->Decoder = 0;
for (unsigned int i = 0; i < FormatContext->nb_streams; i++) {
TrackIndices->push_back(FFTrack((int64_t)FormatContext->streams[i]->time_base.num * 1000,
FormatContext->streams[i]->time_base.den,
static_cast<FFMS_TrackType>(FormatContext->streams[i]->codec->codec_type)));
if (static_cast<FFMS_TrackType>(FormatContext->streams[i]->codec->codec_type) == FFMS_TYPE_VIDEO &&
(VideoContexts[i].Parser = av_parser_init(FormatContext->streams[i]->codec->codec_id))) {
AVCodec *VideoCodec = avcodec_find_decoder(FormatContext->streams[i]->codec->codec_id);
if (VideoCodec == NULL) {
snprintf(ErrorMsg, MsgSize, "Vudio codec not found");
return NULL;
}
if (avcodec_open(FormatContext->streams[i]->codec, VideoCodec) < 0) {
snprintf(ErrorMsg, MsgSize, "Could not open video codec");
return NULL;
}
VideoContexts[i].CodecContext = FormatContext->streams[i]->codec;
VideoContexts[i].Parser->flags = PARSER_FLAG_COMPLETE_FRAMES;
}
if (IndexMask & (1 << i) && FormatContext->streams[i]->codec->codec_type == CODEC_TYPE_AUDIO) {
AVCodecContext *AudioCodecContext = FormatContext->streams[i]->codec;
AVCodec *AudioCodec = avcodec_find_decoder(AudioCodecContext->codec_id);
if (AudioCodec == NULL) {
snprintf(ErrorMsg, MsgSize, "Audio codec not found");
return NULL;
}
if (avcodec_open(AudioCodecContext, AudioCodec) < 0) {
snprintf(ErrorMsg, MsgSize, "Could not open audio codec");
return NULL;
}
AudioContexts[i].CodecContext = AudioCodecContext;
} else {
IndexMask &= ~(1 << i);
}
}
//
AVPacket Packet, TempPacket;
InitNullPacket(&Packet);
InitNullPacket(&TempPacket);
while (av_read_frame(FormatContext, &Packet) >= 0) {
// Update progress
if (IC) {
if ((*IC)(FormatContext->pb->pos, FormatContext->file_size, ICPrivate)) {
snprintf(ErrorMsg, MsgSize, "Cancelled by user");
return NULL;
}
}
// Only create index entries for video for now to save space
if (FormatContext->streams[Packet.stream_index]->codec->codec_type == CODEC_TYPE_VIDEO) {
uint8_t *OB;
int OBSize;
int RepeatPict = -1;
if (VideoContexts[Packet.stream_index].Parser) {
av_parser_parse2(VideoContexts[Packet.stream_index].Parser, VideoContexts[Packet.stream_index].CodecContext, &OB, &OBSize, Packet.data, Packet.size, Packet.pts, Packet.dts, Packet.pos);
RepeatPict = VideoContexts[Packet.stream_index].Parser->repeat_pict;
}
(*TrackIndices)[Packet.stream_index].push_back(TFrameInfo::VideoFrameInfo(Packet.dts, RepeatPict, (Packet.flags & AV_PKT_FLAG_KEY) ? 1 : 0));
} else if (FormatContext->streams[Packet.stream_index]->codec->codec_type == CODEC_TYPE_AUDIO && (IndexMask & (1 << Packet.stream_index))) {
(*TrackIndices)[Packet.stream_index].push_back(TFrameInfo::AudioFrameInfo(Packet.dts, AudioContexts[Packet.stream_index].CurrentSample, (Packet.flags & AV_PKT_FLAG_KEY) ? 1 : 0));
AVCodecContext *AudioCodecContext = FormatContext->streams[Packet.stream_index]->codec;
TempPacket.data = Packet.data;
TempPacket.size = Packet.size;
TempPacket.flags = Packet.flags;
while (TempPacket.size > 0) {
int dbsize = AVCODEC_MAX_AUDIO_FRAME_SIZE*10;
int Ret = avcodec_decode_audio3(AudioCodecContext, &DecodingBuffer[0], &dbsize, &TempPacket);
if (Ret < 0) {
if (IgnoreDecodeErrors) {
(*TrackIndices)[Packet.stream_index].clear();
IndexMask &= ~(1 << Packet.stream_index);
break;
} else {
snprintf(ErrorMsg, MsgSize, "Audio decoding error");
return NULL;
}
}
if (Ret > 0) {
TempPacket.size -= Ret;
TempPacket.data += Ret;
}
if (dbsize > 0)
AudioContexts[Packet.stream_index].CurrentSample += (dbsize * 8) / (av_get_bits_per_sample_format(AudioCodecContext->sample_fmt) * AudioCodecContext->channels);
if (DumpMask & (1 << Packet.stream_index))
WriteAudio(AudioContexts[Packet.stream_index], TrackIndices.get(), Packet.stream_index, dbsize, ErrorMsg, MsgSize);
}
}
av_free_packet(&Packet);
}
TrackIndices->Sort();
return TrackIndices.release();
}
int FFLAVFIndexer::GetNumberOfTracks() {
return FormatContext->nb_streams;
}
FFMS_TrackType FFLAVFIndexer::GetTrackType(int Track) {
return static_cast<FFMS_TrackType>(FormatContext->streams[Track]->codec->codec_type);
}
const char *FFLAVFIndexer::GetTrackCodec(int Track) {
return (avcodec_find_decoder(FormatContext->streams[Track]->codec->codec_id))->long_name;
}

243
aegisub/libffms/src/core/fflavfvideo.cpp Normal file
View file

@ -0,0 +1,243 @@
// Copyright (c) 2007-2009 Fredrik Mellbin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include "ffvideosource.h"
void FFLAVFVideo::Free(bool CloseCodec) {
if (CloseCodec)
avcodec_close(CodecContext);
av_close_input_file(FormatContext);
}
FFLAVFVideo::FFLAVFVideo(const char *SourceFile, int Track, FFIndex *Index,
const char *PP, int Threads, int SeekMode, char *ErrorMsg, unsigned MsgSize)
: FFVideo(SourceFile, Index, ErrorMsg, MsgSize) {
FormatContext = NULL;
AVCodec *Codec = NULL;
this->SeekMode = SeekMode;
VideoTrack = Track;
Frames = (*Index)[VideoTrack];
if (Frames.size() == 0) {
snprintf(ErrorMsg, MsgSize, "Video track contains no frames");
throw ErrorMsg;
}
if (av_open_input_file(&FormatContext, SourceFile, NULL, 0, NULL) != 0) {
snprintf(ErrorMsg, MsgSize, "Couldn't open '%s'", SourceFile);
throw ErrorMsg;
}
if (av_find_stream_info(FormatContext) < 0) {
Free(false);
snprintf(ErrorMsg, MsgSize, "Couldn't find stream information");
throw ErrorMsg;
}
if (SeekMode >= 0 && av_seek_frame(FormatContext, VideoTrack, Frames[0].DTS, AVSEEK_FLAG_BACKWARD) < 0) {
Free(false);
snprintf(ErrorMsg, MsgSize, "Video track is unseekable");
throw ErrorMsg;
}
CodecContext = FormatContext->streams[VideoTrack]->codec;
CodecContext->thread_count = Threads;
Codec = avcodec_find_decoder(CodecContext->codec_id);
if (Codec == NULL) {
Free(false);
snprintf(ErrorMsg, MsgSize, "Video codec not found");
throw ErrorMsg;
}
if (avcodec_open(CodecContext, Codec) < 0) {
Free(false);
snprintf(ErrorMsg, MsgSize, "Could not open video codec");
throw ErrorMsg;
}
// Always try to decode a frame to make sure all required parameters are known
int64_t Dummy;
if (DecodeNextFrame(&Dummy, ErrorMsg, MsgSize)) {
Free(true);
throw ErrorMsg;
}
//VP.image_type = VideoInfo::IT_TFF;
VP.Width = CodecContext->width;
VP.Height = CodecContext->height;
VP.FPSDenominator = FormatContext->streams[VideoTrack]->time_base.num;
VP.FPSNumerator = FormatContext->streams[VideoTrack]->time_base.den;
VP.RFFDenominator = CodecContext->time_base.num;
VP.RFFNumerator = CodecContext->time_base.den;
VP.NumFrames = Frames.size();
VP.VPixelFormat = CodecContext->pix_fmt;
VP.FirstTime = ((Frames.front().DTS * Frames.TB.Num) / (double)Frames.TB.Den) / 1000;
VP.LastTime = ((Frames.back().DTS * Frames.TB.Num) / (double)Frames.TB.Den) / 1000;
if (VP.Width <= 0 || VP.Height <= 0) {
Free(true);
snprintf(ErrorMsg, MsgSize, "Codec returned zero size video");
throw ErrorMsg;
}
// sanity check framerate
if (VP.FPSDenominator > VP.FPSNumerator || VP.FPSDenominator <= 0 || VP.FPSNumerator <= 0) {
VP.FPSDenominator = 1;
VP.FPSNumerator = 30;
}
if (InitPP(PP, ErrorMsg, MsgSize)) {
Free(true);
throw ErrorMsg;
}
// Adjust framerate to match the duration of the first frame
if (Frames.size() >= 2) {
unsigned int DTSDiff = (unsigned int)FFMAX(Frames[1].DTS - Frames[0].DTS, 1);
VP.FPSDenominator *= DTSDiff;
}
// Cannot "output" to PPFrame without doing all other initialization
// This is the additional mess required for seekmode=-1 to work in a reasonable way
if (!OutputFrame(DecodeFrame, ErrorMsg, MsgSize)) {
Free(true);
throw ErrorMsg;
}
// Set AR variables
VP.SARNum = CodecContext->sample_aspect_ratio.num;
VP.SARDen = CodecContext->sample_aspect_ratio.den;
}
FFLAVFVideo::~FFLAVFVideo() {
Free(true);
}
int FFLAVFVideo::DecodeNextFrame(int64_t *AStartTime, char *ErrorMsg, unsigned MsgSize) {
AVPacket Packet;
InitNullPacket(&Packet);
int FrameFinished = 0;
*AStartTime = -1;
while (av_read_frame(FormatContext, &Packet) >= 0) {
if (Packet.stream_index == VideoTrack) {
if (*AStartTime < 0)
*AStartTime = Packet.dts;
avcodec_decode_video2(CodecContext, DecodeFrame, &FrameFinished, &Packet);
}
av_free_packet(&Packet);
if (FrameFinished)
goto Done;
}
// Flush the last frames
if (CodecContext->has_b_frames) {
AVPacket NullPacket;
InitNullPacket(&NullPacket);
avcodec_decode_video2(CodecContext, DecodeFrame, &FrameFinished, &NullPacket);
}
if (!FrameFinished)
goto Error;
// Ignore errors for now
Error:
Done:
return 0;
}
FFAVFrame *FFLAVFVideo::GetFrame(int n, char *ErrorMsg, unsigned MsgSize) {
// PPFrame always holds frame LastFrameNum even if no PP is applied
if (LastFrameNum == n)
return OutputFrame(DecodeFrame, ErrorMsg, MsgSize);
bool HasSeeked = false;
int SeekOffset = 0;
int ClosestKF = 0;
if (SeekMode >= 0) {
ClosestKF = Frames.FindClosestVideoKeyFrame(n);
if (SeekMode == 0) {
if (n < CurrentFrame) {
av_seek_frame(FormatContext, VideoTrack, Frames[0].DTS, AVSEEK_FLAG_BACKWARD);
avcodec_flush_buffers(CodecContext);
CurrentFrame = 0;
}
} else {
// 10 frames is used as a margin to prevent excessive seeking since the predicted best keyframe isn't always selected by avformat
if (n < CurrentFrame || ClosestKF > CurrentFrame + 10 || (SeekMode == 3 && n > CurrentFrame + 10)) {
ReSeek:
av_seek_frame(FormatContext, VideoTrack,
(SeekMode == 3) ? Frames[n].DTS : Frames[ClosestKF + SeekOffset].DTS,
AVSEEK_FLAG_BACKWARD);
avcodec_flush_buffers(CodecContext);
HasSeeked = true;
}
}
} else if (n < CurrentFrame) {
snprintf(ErrorMsg, MsgSize, "Non-linear access attempted");
return NULL;
}
do {
int64_t StartTime;
if (DecodeNextFrame(&StartTime, ErrorMsg, MsgSize))
return NULL;
if (HasSeeked) {
HasSeeked = false;
// Is the seek destination time known? Does it belong to a frame?
if (StartTime < 0 || (CurrentFrame = Frames.FrameFromDTS(StartTime)) < 0) {
switch (SeekMode) {
case 1:
// No idea where we are so go back a bit further
if (ClosestKF + SeekOffset == 0) {
snprintf(ErrorMsg, MsgSize, "Frame accurate seeking is not possible in this file\n");
return NULL;
}
SeekOffset -= FFMIN(10, ClosestKF + SeekOffset);
goto ReSeek;
case 2:
case 3:
CurrentFrame = Frames.ClosestFrameFromDTS(StartTime);
break;
default:
snprintf(ErrorMsg, MsgSize, "Failed assertion");
return NULL;
}
}
}
CurrentFrame++;
} while (CurrentFrame <= n);
LastFrameNum = n;
return OutputFrame(DecodeFrame, ErrorMsg, MsgSize);
}

202
aegisub/libffms/src/core/ffmatroskaaudio.cpp Normal file
View file

@ -0,0 +1,202 @@
// Copyright (c) 2007-2009 Fredrik Mellbin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include "ffaudiosource.h"
void FFMatroskaAudio::Free(bool CloseCodec) {
if (CS)
cs_Destroy(CS);
if (MC.ST.fp) {
mkv_Close(MF);
fclose(MC.ST.fp);
}
if (CloseCodec)
avcodec_close(CodecContext);
av_freep(&CodecContext);
}
FFMatroskaAudio::FFMatroskaAudio(const char *SourceFile, int Track,
FFIndex *Index, char *ErrorMsg, unsigned MsgSize)
: FFAudio(SourceFile, Index, ErrorMsg, MsgSize) {
CodecContext = NULL;
AVCodec *Codec = NULL;
TrackInfo *TI = NULL;
CS = NULL;
Frames = (*Index)[Track];
if (Frames.size() == 0) {
Free(false);
snprintf(ErrorMsg, MsgSize, "Audio track contains no frames, was it indexed properly?");
throw ErrorMsg;
}
MC.ST.fp = ffms_fopen(SourceFile, "rb");
if (MC.ST.fp == NULL) {
snprintf(ErrorMsg, MsgSize, "Can't open '%s': %s", SourceFile, strerror(errno));
throw ErrorMsg;
}
setvbuf(MC.ST.fp, NULL, _IOFBF, CACHESIZE);
MF = mkv_OpenEx(&MC.ST.base, 0, 0, ErrorMessage, sizeof(ErrorMessage));
if (MF == NULL) {
fclose(MC.ST.fp);
snprintf(ErrorMsg, MsgSize, "Can't parse Matroska file: %s", ErrorMessage);
throw ErrorMsg;
}
mkv_SetTrackMask(MF, ~(1 << Track));
TI = mkv_GetTrackInfo(MF, Track);
if (TI->CompEnabled) {
CS = cs_Create(MF, Track, ErrorMessage, sizeof(ErrorMessage));
if (CS == NULL) {
Free(false);
snprintf(ErrorMsg, MsgSize, "Can't create decompressor: %s", ErrorMessage);
throw ErrorMsg;
}
}
CodecContext = avcodec_alloc_context();
Codec = avcodec_find_decoder(MatroskaToFFCodecID(TI->CodecID, TI->CodecPrivate));
if (Codec == NULL) {
Free(false);
snprintf(ErrorMsg, MsgSize, "Video codec not found");
throw ErrorMsg;
}
InitializeCodecContextFromMatroskaTrackInfo(TI, CodecContext);
if (avcodec_open(CodecContext, Codec) < 0) {
Free(false);
snprintf(ErrorMsg, MsgSize, "Could not open video codec");
throw ErrorMsg;
}
// Always try to decode a frame to make sure all required parameters are known
int64_t Dummy;
if (DecodeNextAudioBlock(&Dummy, 0, ErrorMsg, MsgSize) < 0) {
Free(true);
throw ErrorMsg;
}
avcodec_flush_buffers(CodecContext);
FillAP(AP, CodecContext, Frames);
if (AP.SampleRate <= 0 || AP.BitsPerSample <= 0) {
Free(true);
snprintf(ErrorMsg, MsgSize, "Codec returned zero size audio");
throw ErrorMsg;
}
AudioCache.Initialize((AP.Channels * AP.BitsPerSample) / 8, 50);
}
FFMatroskaAudio::~FFMatroskaAudio() {
Free(true);
}
int FFMatroskaAudio::GetAudio(void *Buf, int64_t Start, int64_t Count, char *ErrorMsg, unsigned MsgSize) {
const int64_t SizeConst = (av_get_bits_per_sample_format(CodecContext->sample_fmt) * CodecContext->channels) / 8;
memset(Buf, 0, static_cast<size_t>(SizeConst * Count));
int PreDecBlocks = 0;
uint8_t *DstBuf = static_cast<uint8_t *>(Buf);
// Fill with everything in the cache
int64_t CacheEnd = AudioCache.FillRequest(Start, Count, DstBuf);
// Was everything in the cache?
if (CacheEnd == Start + Count)
return 0;
int CurrentAudioBlock;
// Is seeking required to decode the requested samples?
// if (!(CurrentSample >= Start && CurrentSample <= CacheEnd)) {
if (CurrentSample != CacheEnd) {
PreDecBlocks = 15;
CurrentAudioBlock = FFMAX((int64_t)Frames.FindClosestAudioKeyFrame(CacheEnd) - PreDecBlocks, (int64_t)0);
avcodec_flush_buffers(CodecContext);
} else {
CurrentAudioBlock = Frames.FindClosestAudioKeyFrame(CurrentSample);
}
int64_t DecodeCount;
do {
int Ret = DecodeNextAudioBlock(&DecodeCount, CurrentAudioBlock, ErrorMsg, MsgSize);
if (Ret < 0) {
// FIXME
//Env->ThrowError("Bleh, bad audio decoding");
}
// Cache the block if enough blocks before it have been decoded to avoid garbage
if (PreDecBlocks == 0) {
AudioCache.CacheBlock(Frames[CurrentAudioBlock].SampleStart, DecodeCount, &DecodingBuffer[0]);
CacheEnd = AudioCache.FillRequest(CacheEnd, Start + Count - CacheEnd, DstBuf + (CacheEnd - Start) * SizeConst);
} else {
PreDecBlocks--;
}
CurrentAudioBlock++;
if (CurrentAudioBlock < static_cast<int>(Frames.size()))
CurrentSample = Frames[CurrentAudioBlock].SampleStart;
} while (Start + Count - CacheEnd > 0 && CurrentAudioBlock < static_cast<int>(Frames.size()));
return 0;
}
int FFMatroskaAudio::DecodeNextAudioBlock(int64_t *Count, int AudioBlock, char *ErrorMsg, unsigned MsgSize) {
const size_t SizeConst = (av_get_bits_per_sample_format(CodecContext->sample_fmt) * CodecContext->channels) / 8;
int Ret = -1;
*Count = 0;
uint8_t *Buf = &DecodingBuffer[0];
AVPacket TempPacket;
InitNullPacket(&TempPacket);
unsigned int FrameSize = Frames[AudioBlock].FrameSize;
if (ReadFrame(Frames[AudioBlock].FilePos, FrameSize, CS, MC, ErrorMsg, MsgSize))
return 1;
TempPacket.data = MC.Buffer;
TempPacket.size = FrameSize;
if (Frames[AudioBlock].KeyFrame)
TempPacket.flags = AV_PKT_FLAG_KEY;
else
TempPacket.flags = 0;
while (TempPacket.size > 0) {
int TempOutputBufSize = AVCODEC_MAX_AUDIO_FRAME_SIZE;
Ret = avcodec_decode_audio3(CodecContext, (int16_t *)Buf, &TempOutputBufSize, &TempPacket);
if (Ret < 0) // throw error or something?
goto Done;
if (Ret > 0) {
TempPacket.size -= Ret;
TempPacket.data += Ret;
Buf += TempOutputBufSize;
if (SizeConst)
*Count += TempOutputBufSize / SizeConst;
}
}
Done:
return 0;
}

213
aegisub/libffms/src/core/ffmatroskaindexer.cpp Normal file
View file

@ -0,0 +1,213 @@
// Copyright (c) 2007-2009 Fredrik Mellbin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include "indexing.h"
#include "matroskaparser.h"
FFMatroskaIndexer::FFMatroskaIndexer(const char *Filename, char *ErrorMsg, unsigned MsgSize) : FFIndexer(Filename, ErrorMsg, MsgSize) {
memset(Codec, 0, sizeof(Codec));
SourceFile = Filename;
char ErrorMessage[256];
InitStdIoStream(&MC.ST);
MC.ST.fp = ffms_fopen(SourceFile, "rb");
if (MC.ST.fp == NULL) {
snprintf(ErrorMsg, MsgSize, "Can't open '%s': %s", SourceFile, strerror(errno));
throw ErrorMsg;
}
setvbuf(MC.ST.fp, NULL, _IOFBF, CACHESIZE);
MF = mkv_OpenEx(&MC.ST.base, 0, 0, ErrorMessage, sizeof(ErrorMessage));
if (MF == NULL) {
fclose(MC.ST.fp);
snprintf(ErrorMsg, MsgSize, "Can't parse Matroska file: %s", ErrorMessage);
throw ErrorMsg;
}
for (unsigned int i = 0; i < mkv_GetNumTracks(MF); i++) {
TrackInfo *TI = mkv_GetTrackInfo(MF, i);
Codec[i] = avcodec_find_decoder(MatroskaToFFCodecID(TI->CodecID, TI->CodecPrivate));
}
}
FFMatroskaIndexer::~FFMatroskaIndexer() {
mkv_Close(MF);
fclose(MC.ST.fp);
}
FFIndex *FFMatroskaIndexer::DoIndexing(char *ErrorMsg, unsigned MsgSize) {
char ErrorMessage[256];
std::vector<SharedAudioContext> AudioContexts(mkv_GetNumTracks(MF), SharedAudioContext(true));
std::vector<SharedVideoContext> VideoContexts(mkv_GetNumTracks(MF), SharedVideoContext(true));
std::auto_ptr<FFIndex> TrackIndices(new FFIndex(Filesize, Digest));
TrackIndices->Decoder = 1;
for (unsigned int i = 0; i < mkv_GetNumTracks(MF); i++) {
TrackInfo *TI = mkv_GetTrackInfo(MF, i);
TrackIndices->push_back(FFTrack(mkv_TruncFloat(mkv_GetTrackInfo(MF, i)->TimecodeScale), 1000000, HaaliTrackTypeToFFTrackType(mkv_GetTrackInfo(MF, i)->Type)));
if (HaaliTrackTypeToFFTrackType(TI->Type) == FFMS_TYPE_VIDEO && Codec[i] && (VideoContexts[i].Parser = av_parser_init(Codec[i]->id))) {
AVCodecContext *CodecContext = avcodec_alloc_context();
InitializeCodecContextFromMatroskaTrackInfo(TI, CodecContext);
if (avcodec_open(CodecContext, Codec[i]) < 0) {
av_freep(&CodecContext);
snprintf(ErrorMsg, MsgSize, "Could not open video codec");
return NULL;
}
if (TI->CompEnabled) {
VideoContexts[i].CS = cs_Create(MF, i, ErrorMessage, sizeof(ErrorMessage));
if (VideoContexts[i].CS == NULL) {
snprintf(ErrorMsg, MsgSize, "Can't create decompressor: %s", ErrorMessage);
return NULL;
}
}
VideoContexts[i].CodecContext = CodecContext;
VideoContexts[i].Parser->flags = PARSER_FLAG_COMPLETE_FRAMES;
}
if (IndexMask & (1 << i) && TI->Type == TT_AUDIO) {
AVCodecContext *AudioCodecContext = avcodec_alloc_context();
AudioCodecContext->extradata = (uint8_t *)TI->CodecPrivate;
AudioCodecContext->extradata_size = TI->CodecPrivateSize;
AudioContexts[i].CodecContext = AudioCodecContext;
if (TI->CompEnabled) {
AudioContexts[i].CS = cs_Create(MF, i, ErrorMessage, sizeof(ErrorMessage));
if (AudioContexts[i].CS == NULL) {
av_freep(&AudioCodecContext);
AudioContexts[i].CodecContext = NULL;
snprintf(ErrorMsg, MsgSize, "Can't create decompressor: %s", ErrorMessage);
return NULL;
}
}
AVCodec *AudioCodec = Codec[i];
if (AudioCodec == NULL) {
av_freep(&AudioCodecContext);
AudioContexts[i].CodecContext = NULL;
snprintf(ErrorMsg, MsgSize, "Audio codec not found");
return NULL;
}
if (avcodec_open(AudioCodecContext, AudioCodec) < 0) {
av_freep(&AudioCodecContext);
AudioContexts[i].CodecContext = NULL;
snprintf(ErrorMsg, MsgSize, "Could not open audio codec");
return NULL;
}
} else {
IndexMask &= ~(1 << i);
}
}
//
ulonglong StartTime, EndTime, FilePos;
unsigned int Track, FrameFlags, FrameSize;
AVPacket TempPacket;
InitNullPacket(&TempPacket);
while (mkv_ReadFrame(MF, 0, &Track, &StartTime, &EndTime, &FilePos, &FrameSize, &FrameFlags) == 0) {
// Update progress
if (IC) {
if ((*IC)(ftello(MC.ST.fp), Filesize, ICPrivate)) {
snprintf(ErrorMsg, MsgSize, "Cancelled by user");
return NULL;
}
}
// Only create index entries for video for now to save space
if (mkv_GetTrackInfo(MF, Track)->Type == TT_VIDEO) {
uint8_t *OB;
int OBSize;
int RepeatPict = -1;
if (VideoContexts[Track].Parser) {
av_parser_parse2(VideoContexts[Track].Parser, VideoContexts[Track].CodecContext, &OB, &OBSize, TempPacket.data, TempPacket.size, ffms_av_nopts_value, ffms_av_nopts_value, ffms_av_nopts_value);
RepeatPict = VideoContexts[Track].Parser->repeat_pict;
}
(*TrackIndices)[Track].push_back(TFrameInfo::VideoFrameInfo(StartTime, RepeatPict, (FrameFlags & FRAME_KF) != 0, FilePos, FrameSize));
} else if (mkv_GetTrackInfo(MF, Track)->Type == TT_AUDIO && (IndexMask & (1 << Track))) {
(*TrackIndices)[Track].push_back(TFrameInfo::AudioFrameInfo(StartTime, AudioContexts[Track].CurrentSample, (FrameFlags & FRAME_KF) != 0, FilePos, FrameSize));
ReadFrame(FilePos, FrameSize, AudioContexts[Track].CS, MC, ErrorMsg, MsgSize);
AVCodecContext *AudioCodecContext = AudioContexts[Track].CodecContext;
TempPacket.data = MC.Buffer;
TempPacket.size = FrameSize;
if ((FrameFlags & FRAME_KF) != 0)
TempPacket.flags = AV_PKT_FLAG_KEY;
else
TempPacket.flags = 0;
while (TempPacket.size > 0) {
int dbsize = AVCODEC_MAX_AUDIO_FRAME_SIZE*10;
int Ret = avcodec_decode_audio3(AudioCodecContext, &DecodingBuffer[0], &dbsize, &TempPacket);
if (Ret < 0) {
if (IgnoreDecodeErrors) {
(*TrackIndices)[Track].clear();
IndexMask &= ~(1 << Track);
break;
} else {
snprintf(ErrorMsg, MsgSize, "Audio decoding error");
return NULL;
}
}
if (Ret > 0) {
TempPacket.size -= Ret;
TempPacket.data += Ret;
}
if (dbsize > 0)
AudioContexts[Track].CurrentSample += (dbsize * 8) / (av_get_bits_per_sample_format(AudioCodecContext->sample_fmt) * AudioCodecContext->channels);
if (DumpMask & (1 << Track))
WriteAudio(AudioContexts[Track], TrackIndices.get(), Track, dbsize, ErrorMsg, MsgSize);
}
}
}
TrackIndices->Sort();
return TrackIndices.release();
}
int FFMatroskaIndexer::GetNumberOfTracks() {
return mkv_GetNumTracks(MF);
}
FFMS_TrackType FFMatroskaIndexer::GetTrackType(int Track) {
return HaaliTrackTypeToFFTrackType(mkv_GetTrackInfo(MF, Track)->Type);
}
const char *FFMatroskaIndexer::GetTrackCodec(int Track) {
if (Codec[Track])
return Codec[Track]->long_name;
else
return "Unsupported codec/Unknown codec name";
}

230
aegisub/libffms/src/core/ffmatroskavideo.cpp Normal file
View file

@ -0,0 +1,230 @@
// Copyright (c) 2007-2009 Fredrik Mellbin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include "ffvideosource.h"
void FFMatroskaVideo::Free(bool CloseCodec) {
if (CS)
cs_Destroy(CS);
if (MC.ST.fp) {
mkv_Close(MF);
fclose(MC.ST.fp);
}
if (CloseCodec)
avcodec_close(CodecContext);
av_freep(&CodecContext);
}
FFMatroskaVideo::FFMatroskaVideo(const char *SourceFile, int Track,
FFIndex *Index, const char *PP,
int Threads, char *ErrorMsg, unsigned MsgSize)
: FFVideo(SourceFile, Index, ErrorMsg, MsgSize) {
AVCodec *Codec = NULL;
CodecContext = NULL;
TrackInfo *TI = NULL;
CS = NULL;
VideoTrack = Track;
Frames = (*Index)[VideoTrack];
if (Frames.size() == 0) {
snprintf(ErrorMsg, MsgSize, "Video track contains no frames");
throw ErrorMsg;
}
MC.ST.fp = ffms_fopen(SourceFile, "rb");
if (MC.ST.fp == NULL) {
snprintf(ErrorMsg, MsgSize, "Can't open '%s': %s", SourceFile, strerror(errno));
throw ErrorMsg;
}
setvbuf(MC.ST.fp, NULL, _IOFBF, CACHESIZE);
MF = mkv_OpenEx(&MC.ST.base, 0, 0, ErrorMessage, sizeof(ErrorMessage));
if (MF == NULL) {
fclose(MC.ST.fp);
snprintf(ErrorMsg, MsgSize, "Can't parse Matroska file: %s", ErrorMessage);
throw ErrorMsg;
}
mkv_SetTrackMask(MF, ~(1 << VideoTrack));
TI = mkv_GetTrackInfo(MF, VideoTrack);
if (TI->CompEnabled) {
CS = cs_Create(MF, VideoTrack, ErrorMessage, sizeof(ErrorMessage));
if (CS == NULL) {
Free(false);
snprintf(ErrorMsg, MsgSize, "Can't create decompressor: %s", ErrorMessage);
throw ErrorMsg;
}
}
CodecContext = avcodec_alloc_context();
CodecContext->thread_count = Threads;
Codec = avcodec_find_decoder(MatroskaToFFCodecID(TI->CodecID, TI->CodecPrivate));
if (Codec == NULL) {
Free(false);
snprintf(ErrorMsg, MsgSize, "Video codec not found");
throw ErrorMsg;
}
InitializeCodecContextFromMatroskaTrackInfo(TI, CodecContext);
if (avcodec_open(CodecContext, Codec) < 0) {
Free(false);
snprintf(ErrorMsg, MsgSize, "Could not open video codec");
throw ErrorMsg;
}
// Always try to decode a frame to make sure all required parameters are known
int64_t Dummy;
if (DecodeNextFrame(&Dummy, ErrorMsg, MsgSize)) {
Free(true);
throw ErrorMsg;
}
VP.Width = CodecContext->width;
VP.Height = CodecContext->height;;
VP.FPSDenominator = 1;
VP.FPSNumerator = 30;
VP.RFFDenominator = CodecContext->time_base.num;
VP.RFFNumerator = CodecContext->time_base.den;
VP.NumFrames = Frames.size();
VP.VPixelFormat = CodecContext->pix_fmt;
VP.FirstTime = ((Frames.front().DTS * Frames.TB.Num) / (double)Frames.TB.Den) / 1000;
VP.LastTime = ((Frames.back().DTS * Frames.TB.Num) / (double)Frames.TB.Den) / 1000;
if (VP.Width <= 0 || VP.Height <= 0) {
Free(true);
snprintf(ErrorMsg, MsgSize, "Codec returned zero size video");
throw ErrorMsg;
}
if (InitPP(PP, ErrorMsg, MsgSize)) {
Free(true);
throw ErrorMsg;
}
// Calculate the average framerate
if (Frames.size() >= 2) {
double DTSDiff = (double)(Frames.back().DTS - Frames.front().DTS);
VP.FPSDenominator = (unsigned int)(DTSDiff * mkv_TruncFloat(TI->TimecodeScale) / (double)1000 / (double)(VP.NumFrames - 1) + 0.5);
VP.FPSNumerator = 1000000;
}
// Output the already decoded frame so it isn't wasted
if (!OutputFrame(DecodeFrame, ErrorMsg, MsgSize)) {
Free(true);
throw ErrorMsg;
}
// 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;
}
FFMatroskaVideo::~FFMatroskaVideo() {
Free(true);
}
int FFMatroskaVideo::DecodeNextFrame(int64_t *AFirstStartTime, char *ErrorMsg, unsigned MsgSize) {
int FrameFinished = 0;
*AFirstStartTime = -1;
AVPacket Packet;
InitNullPacket(&Packet);
ulonglong StartTime, EndTime, FilePos;
unsigned int Track, FrameFlags, FrameSize;
while (mkv_ReadFrame(MF, 0, &Track, &StartTime, &EndTime, &FilePos, &FrameSize, &FrameFlags) == 0) {
if (*AFirstStartTime < 0)
*AFirstStartTime = StartTime;
if (ReadFrame(FilePos, FrameSize, CS, MC, ErrorMsg, MsgSize))
return 1;
Packet.data = MC.Buffer;
Packet.size = FrameSize;
if (FrameFlags & FRAME_KF)
Packet.flags = AV_PKT_FLAG_KEY;
else
Packet.flags = 0;
avcodec_decode_video2(CodecContext, DecodeFrame, &FrameFinished, &Packet);
if (FrameFinished)
goto Done;
}
// Flush the last frames
if (CodecContext->has_b_frames) {
AVPacket NullPacket;
InitNullPacket(&NullPacket);
avcodec_decode_video2(CodecContext, DecodeFrame, &FrameFinished, &NullPacket);
}
if (!FrameFinished)
goto Error;
Error:
Done:
return 0;
}
FFAVFrame *FFMatroskaVideo::GetFrame(int n, char *ErrorMsg, unsigned MsgSize) {
// PPFrame always holds frame LastFrameNum even if no PP is applied
if (LastFrameNum == n)
return OutputFrame(DecodeFrame, ErrorMsg, MsgSize);
bool HasSeeked = false;
if (n < CurrentFrame || Frames.FindClosestVideoKeyFrame(n) > CurrentFrame) {
mkv_Seek(MF, Frames[n].DTS, MKVF_SEEK_TO_PREV_KEYFRAME_STRICT);
avcodec_flush_buffers(CodecContext);
HasSeeked = true;
}
do {
int64_t StartTime;
if (DecodeNextFrame(&StartTime, ErrorMsg, MsgSize))
return NULL;
if (HasSeeked) {
HasSeeked = false;
if (StartTime < 0 || (CurrentFrame = Frames.FrameFromDTS(StartTime)) < 0) {
snprintf(ErrorMsg, MsgSize, "Frame accurate seeking is not possible in this file");
return NULL;
}
}
CurrentFrame++;
} while (CurrentFrame <= n);
LastFrameNum = n;
return OutputFrame(DecodeFrame, ErrorMsg, MsgSize);
}

147
aegisub/libffms/ffms.cpp → aegisub/libffms/src/core/ffms.cpp
View file

@ -18,25 +18,63 @@
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
extern "C" {
#include <libavcodec/avcodec.h>
}
#include <sstream>
#include <iomanip>
#include "ffms.h"
#include "ffvideosource.h"
#include "ffaudiosource.h"
#include "indexing.h"
#ifdef __UNIX__
#define _snprintf snprintf
#endif
static bool FFmpegInited = false;
int CPUFeatures = 0;
FFMS_API(void) FFMS_Init() {
#ifdef FFMS_WIN_DEBUG
extern "C" int av_log_level;
void av_log_windebug_callback(void* ptr, int level, const char* fmt, va_list vl)
{
static int print_prefix=1;
static int count;
static char line[1024], prev[1024];
AVClass* avc= ptr ? *(AVClass**)ptr : NULL;
if(level>av_log_level)
return;
#undef fprintf
if(print_prefix && avc) {
snprintf(line, sizeof(line), "[%s @ %p]", avc->item_name(ptr), ptr);
}else
line[0]=0;
vsnprintf(line + strlen(line), sizeof(line) - strlen(line), fmt, vl);
print_prefix= line[strlen(line)-1] == '\n';
if(print_prefix && !strcmp(line, prev)){
count++;
return;
}
if(count>0){
fprintf(stderr, " Last message repeated %d times\n", count);
count=0;
}
OutputDebugStringA(line);
strcpy(prev, line);
}
#endif
FFMS_API(void) FFMS_Init(int CPUFeatures) {
if (!FFmpegInited) {
av_register_all();
#ifdef FFMS_WIN_DEBUG
av_log_set_callback(av_log_windebug_callback);
av_log_set_level(AV_LOG_INFO);
#else
av_log_set_level(AV_LOG_QUIET);
#endif
::CPUFeatures = CPUFeatures;
FFmpegInited = true;
}
}
@ -46,17 +84,17 @@ FFMS_API(int) FFMS_GetLogLevel() {
}
FFMS_API(void) FFMS_SetLogLevel(int Level) {
av_log_set_level(AV_LOG_QUIET);
av_log_set_level(Level);
}
FFMS_API(FFVideo *) FFMS_CreateVideoSource(const char *SourceFile, int Track, FFIndex *Index, const char *PP, int Threads, int SeekMode, char *ErrorMsg, unsigned MsgSize) {
if (Track < 0 || Track >= Index->size()) {
_snprintf(ErrorMsg, MsgSize, "Out of bounds track index selected");
if (Track < 0 || Track >= static_cast<int>(Index->size())) {
snprintf(ErrorMsg, MsgSize, "Out of bounds track index selected");
return NULL;
}
if (Index->at(Track).TT != FFMS_TYPE_VIDEO) {
_snprintf(ErrorMsg, MsgSize, "Not a video track");
snprintf(ErrorMsg, MsgSize, "Not a video track");
return NULL;
}
@ -69,7 +107,7 @@ FFMS_API(FFVideo *) FFMS_CreateVideoSource(const char *SourceFile, int Track, FF
case 3: return new FFHaaliVideo(SourceFile, Track, Index, PP, Threads, 1, ErrorMsg, MsgSize);
#endif
default:
_snprintf(ErrorMsg, MsgSize, "Unsupported format");
snprintf(ErrorMsg, MsgSize, "Unsupported format");
return NULL;
}
} catch (...) {
@ -78,13 +116,13 @@ FFMS_API(FFVideo *) FFMS_CreateVideoSource(const char *SourceFile, int Track, FF
}
FFMS_API(FFAudio *) FFMS_CreateAudioSource(const char *SourceFile, int Track, FFIndex *Index, char *ErrorMsg, unsigned MsgSize) {
if (Track < 0 || Track >= Index->size()) {
_snprintf(ErrorMsg, MsgSize, "Out of bounds track index selected");
if (Track < 0 || Track >= static_cast<int>(Index->size())) {
snprintf(ErrorMsg, MsgSize, "Out of bounds track index selected");
return NULL;
}
if (Index->at(Track).TT != FFMS_TYPE_AUDIO) {
_snprintf(ErrorMsg, MsgSize, "Not an audio track");
snprintf(ErrorMsg, MsgSize, "Not an audio track");
return NULL;
}
@ -97,7 +135,7 @@ FFMS_API(FFAudio *) FFMS_CreateAudioSource(const char *SourceFile, int Track, FF
case 3: return new FFHaaliAudio(SourceFile, Track, Index, 1, ErrorMsg, MsgSize);
#endif
default:
_snprintf(ErrorMsg, MsgSize, "Unsupported format");
snprintf(ErrorMsg, MsgSize, "Unsupported format");
return NULL;
}
} catch (...) {
@ -113,31 +151,31 @@ FFMS_API(void) FFMS_DestroyAudioSource(FFAudio *A) {
delete A;
}
FFMS_API(const TVideoProperties *) FFMS_GetVideoProperties(FFVideo *V) {
return &V->GetTVideoProperties();
FFMS_API(const FFVideoProperties *) FFMS_GetVideoProperties(FFVideo *V) {
return &V->GetFFVideoProperties();
}
FFMS_API(const TAudioProperties *) FFMS_GetAudioProperties(FFAudio *A) {
return &A->GetTAudioProperties();
FFMS_API(const FFAudioProperties *) FFMS_GetAudioProperties(FFAudio *A) {
return &A->GetFFAudioProperties();
}
FFMS_API(const TAVFrameLite *) FFMS_GetFrame(FFVideo *V, int n, char *ErrorMsg, unsigned MsgSize) {
return (TAVFrameLite *)V->GetFrame(n, ErrorMsg, MsgSize);
FFMS_API(const FFAVFrame *) FFMS_GetFrame(FFVideo *V, int n, char *ErrorMsg, unsigned MsgSize) {
return (FFAVFrame *)V->GetFrame(n, ErrorMsg, MsgSize);
}
FFMS_API(const TAVFrameLite *) FFMS_GetFrameByTime(FFVideo *V, double Time, char *ErrorMsg, unsigned MsgSize) {
return (TAVFrameLite *)V->GetFrameByTime(Time, ErrorMsg, MsgSize);
FFMS_API(const FFAVFrame *) FFMS_GetFrameByTime(FFVideo *V, double Time, char *ErrorMsg, unsigned MsgSize) {
return (FFAVFrame *)V->GetFrameByTime(Time, ErrorMsg, MsgSize);
}
FFMS_API(int) FFMS_GetAudio(FFAudio *A, void *Buf, int64_t Start, int64_t Count, char *ErrorMsg, unsigned MsgSize) {
return A->GetAudio(Buf, Start, Count, ErrorMsg, MsgSize);
}
FFMS_API(int) FFMS_SetOutputFormat(FFVideo *V, int64_t TargetFormats, int Width, int Height, char *ErrorMsg, unsigned MsgSize) {
return V->SetOutputFormat(TargetFormats, Width, Height, ErrorMsg, MsgSize);
FFMS_API(int) FFMS_SetOutputFormatV(FFVideo *V, int64_t TargetFormats, int Width, int Height, int Resizer, char *ErrorMsg, unsigned MsgSize) {
return V->SetOutputFormat(TargetFormats, Width, Height, Resizer, ErrorMsg, MsgSize);
}
FFMS_API(void) FFMS_ResetOutputFormat(FFVideo *V) {
FFMS_API(void) FFMS_ResetOutputFormatV(FFVideo *V) {
V->ResetOutputFormat();
}
@ -149,7 +187,7 @@ FFMS_API(int) FFMS_GetFirstTrackOfType(FFIndex *Index, int TrackType, char *Erro
for (int i = 0; i < static_cast<int>(Index->size()); i++)
if ((*Index)[i].TT == TrackType)
return i;
_snprintf(ErrorMsg, MsgSize, "No suitable, indexed track found");
snprintf(ErrorMsg, MsgSize, "No suitable, indexed track found");
return -1;
}
@ -157,7 +195,7 @@ FFMS_API(int) FFMS_GetFirstIndexedTrackOfType(FFIndex *Index, int TrackType, cha
for (int i = 0; i < static_cast<int>(Index->size()); i++)
if ((*Index)[i].TT == TrackType && (*Index)[i].size() > 0)
return i;
_snprintf(ErrorMsg, MsgSize, "No suitable, indexed track found");
snprintf(ErrorMsg, MsgSize, "No suitable, indexed track found");
return -1;
}
@ -169,11 +207,11 @@ FFMS_API(int) FFMS_GetNumTracksI(FFIndexer *Indexer) {
return Indexer->GetNumberOfTracks();
}
FFMS_API(FFMS_TrackType) FFMS_GetTrackType(FFTrack *T) {
FFMS_API(int) FFMS_GetTrackType(FFTrack *T) {
return T->TT;
}
FFMS_API(FFMS_TrackType) FFMS_GetTrackTypeI(FFIndexer *Indexer, int Track) {
FFMS_API(int) FFMS_GetTrackTypeI(FFIndexer *Indexer, int Track) {
return Indexer->GetTrackType(Track);
}
@ -201,7 +239,7 @@ FFMS_API(FFTrack *) FFMS_GetTrackFromAudio(FFAudio *A) {
return A->GetFFTrack();
}
FFMS_API(const TTrackTimeBase *) FFMS_GetTimeBase(FFTrack *T) {
FFMS_API(const FFTrackTimeBase *) FFMS_GetTimeBase(FFTrack *T) {
return &T->TB;
}
@ -216,12 +254,39 @@ FFMS_API(FFIndex *) FFMS_MakeIndex(const char *SourceFile, int IndexMask, int Du
return FFMS_DoIndexing(Indexer, IndexMask, DumpMask, ANC, ANCPrivate, IgnoreDecodeErrors, IC, ICPrivate, ErrorMsg, MsgSize);
}
FFMS_API(int) FFMS_DefaultAudioFilename(const char *SourceFile, int Track, const TAudioProperties *AP, char *FileName, void *Private) {
const char * FormatString = "%s.Track%d.delay%dms.w64";
if (FileName == NULL)
return _snprintf(NULL, 0, FormatString, SourceFile, Track, (int)AP->FirstTime) + 1;
else
return _snprintf(FileName, 999999, FormatString, SourceFile, Track, (int)AP->FirstTime) + 1;
/* Used by FFMS_DefaultAudioFilename */
static std::string IntToStr(int i, int zp = 0) {
std::stringstream s;
s.fill('0');
s.width(zp);
s << i;
return s.str();
}
static void ReplaceString(std::string &s, std::string from, std::string to) {
int idx;
while ((idx = s.find(from)) != std::string::npos)
s.replace(idx, from.length(), to);
}
FFMS_API(int) FFMS_DefaultAudioFilename(const char *SourceFile, int Track, const FFAudioProperties *AP, char *FileName, int FNSize, void *Private) {
std::string s = static_cast<char *>(Private);
ReplaceString(s, "%sourcefile%", SourceFile);
ReplaceString(s, "%trackn%", IntToStr(Track));
ReplaceString(s, "%trackzn%", IntToStr(Track, 2));
ReplaceString(s, "%samplerate%", IntToStr(AP->SampleRate));
ReplaceString(s, "%channels%", IntToStr(AP->Channels));
ReplaceString(s, "%bps%", IntToStr(AP->BitsPerSample));
ReplaceString(s, "%delay%", IntToStr(static_cast<int>(AP->FirstTime)));
if (FileName == NULL) {
return s.length() + 1;
} else {
strcpy(FileName, s.c_str());
return 0;
}
}
FFMS_API(FFIndexer *) FFMS_CreateIndexer(const char *SourceFile, char *ErrorMsg, unsigned MsgSize) {
@ -257,6 +322,10 @@ FFMS_API(FFIndex *) FFMS_ReadIndex(const char *IndexFile, char *ErrorMsg, unsign
}
}
FFMS_API(int) FFMS_IndexBelongsToFile(FFIndex *Index, const char *SourceFile, char *ErrorMsg, unsigned MsgSize) {
return Index->CompareFileSignature(SourceFile, ErrorMsg, MsgSize);
}
FFMS_API(int) FFMS_WriteIndex(const char *IndexFile, FFIndex *Index, char *ErrorMsg, unsigned MsgSize) {
return Index->WriteIndex(IndexFile, ErrorMsg, MsgSize);
}

219
aegisub/libffms/src/core/ffvideosource.cpp Normal file
View file

@ -0,0 +1,219 @@
// Copyright (c) 2007-2009 Fredrik Mellbin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include "ffvideosource.h"
int FFVideo::InitPP(const char *PP, char *ErrorMsg, unsigned MsgSize) {
if (PP == NULL || !strcmp(PP, ""))
return 0;
PPMode = pp_get_mode_by_name_and_quality(PP, PP_QUALITY_MAX);
if (!PPMode) {
snprintf(ErrorMsg, MsgSize, "Invalid postprocesing settings");
return 1;
}
return 0;
}
int FFVideo::ReAdjustPP(PixelFormat VPixelFormat, int Width, int Height, char *ErrorMsg, unsigned MsgSize) {
if (!PPMode)
return 0;
int Flags = GetPPCPUFlags();
switch (VPixelFormat) {
case PIX_FMT_YUV420P: Flags |= PP_FORMAT_420; break;
case PIX_FMT_YUV422P: Flags |= PP_FORMAT_422; break;
case PIX_FMT_YUV411P: Flags |= PP_FORMAT_411; break;
case PIX_FMT_YUV444P: Flags |= PP_FORMAT_444; break;
default:
snprintf(ErrorMsg, MsgSize, "Input format is not supported for postprocessing");
return 1;
}
if (PPContext)
pp_free_context(PPContext);
PPContext = pp_get_context(Width, Height, Flags);
avpicture_free(&PPFrame);
avpicture_alloc(&PPFrame, VPixelFormat, Width, Height);
return 0;
}
static void CopyAVPictureFields(AVPicture &Picture, FFAVFrame &Dst) {
for (int i = 0; i < 4; i++) {
Dst.Data[i] = Picture.data[i];
Dst.Linesize[i] = Picture.linesize[i];
}
}
FFAVFrame *FFVideo::OutputFrame(AVFrame *Frame, char *ErrorMsg, unsigned MsgSize) {
if (LastFrameWidth != CodecContext->width || LastFrameHeight != CodecContext->height || LastFramePixelFormat != CodecContext->pix_fmt) {
if (ReAdjustPP(CodecContext->pix_fmt, CodecContext->width, CodecContext->height, ErrorMsg, MsgSize))
return NULL;
if (TargetHeight > 0 && TargetWidth > 0 && TargetPixelFormats != 0)
if (ReAdjustOutputFormat(TargetPixelFormats, TargetWidth, TargetHeight, TargetResizer, ErrorMsg, MsgSize))
return NULL;
}
if (PPMode) {
pp_postprocess(const_cast<const uint8_t **>(Frame->data), Frame->linesize, PPFrame.data, PPFrame.linesize, CodecContext->width, CodecContext->height, Frame->qscale_table, Frame->qstride, PPMode, PPContext, Frame->pict_type | (Frame->qscale_type ? PP_PICT_TYPE_QP2 : 0));
if (SWS) {
sws_scale(SWS, PPFrame.data, PPFrame.linesize, 0, CodecContext->height, SWSFrame.data, SWSFrame.linesize);
CopyAVPictureFields(SWSFrame, LocalFrame);
} else {
CopyAVPictureFields(PPFrame, LocalFrame);
}
} else {
if (SWS) {
sws_scale(SWS, Frame->data, Frame->linesize, 0, CodecContext->height, SWSFrame.data, SWSFrame.linesize);
CopyAVPictureFields(SWSFrame, LocalFrame);
} else {
// Special case to avoid ugly casts
for (int i = 0; i < 4; i++) {
LocalFrame.Data[i] = Frame->data[i];
LocalFrame.Linesize[i] = Frame->linesize[i];
}
}
}
LocalFrame.EncodedWidth = CodecContext->width;
LocalFrame.EncodedHeight = CodecContext->height;
LocalFrame.EncodedPixelFormat = CodecContext->pix_fmt;
LocalFrame.ScaledWidth = VP.Width;
LocalFrame.ScaledHeight = VP.Height;
LocalFrame.ConvertedPixelFormat = VP.VPixelFormat;
LocalFrame.KeyFrame = Frame->key_frame;
LocalFrame.PictType = av_get_pict_type_char(Frame->pict_type);
LocalFrame.RepeatPict = Frame->repeat_pict;
LocalFrame.InterlacedFrame = Frame->interlaced_frame;
LocalFrame.TopFieldFirst = Frame->top_field_first;
LastFrameHeight = CodecContext->height;
LastFrameWidth = CodecContext->width;
LastFramePixelFormat = CodecContext->pix_fmt;
return &LocalFrame;
}
FFVideo::FFVideo(const char *SourceFile, FFIndex *Index, char *ErrorMsg, unsigned MsgSize) {
if (Index->CompareFileSignature(SourceFile, ErrorMsg, MsgSize))
throw ErrorMsg;
memset(&VP, 0, sizeof(VP));
PPContext = NULL;
PPMode = NULL;
SWS = NULL;
LastFrameNum = 0;
CurrentFrame = 1;
CodecContext = NULL;
LastFrameHeight = -1;
LastFrameWidth = -1;
LastFramePixelFormat = PIX_FMT_NONE;
TargetHeight = -1;
TargetWidth = -1;
TargetPixelFormats = 0;
TargetResizer = 0;
DecodeFrame = avcodec_alloc_frame();
// Dummy allocations so the unallocated case doesn't have to be handled later
avpicture_alloc(&PPFrame, PIX_FMT_GRAY8, 16, 16);
avpicture_alloc(&SWSFrame, PIX_FMT_GRAY8, 16, 16);
}
FFVideo::~FFVideo() {
if (PPMode)
pp_free_mode(PPMode);
if (PPContext)
pp_free_context(PPContext);
if (SWS)
sws_freeContext(SWS);
avpicture_free(&PPFrame);
avpicture_free(&SWSFrame);
av_freep(&DecodeFrame);
}
FFAVFrame *FFVideo::GetFrameByTime(double Time, char *ErrorMsg, unsigned MsgSize) {
int Frame = Frames.ClosestFrameFromDTS(static_cast<int64_t>((Time * 1000 * Frames.TB.Den) / Frames.TB.Num));
return GetFrame(Frame, ErrorMsg, MsgSize);
}
int FFVideo::SetOutputFormat(int64_t TargetFormats, int Width, int Height, int Resizer, char *ErrorMsg, unsigned MsgSize) {
this->TargetWidth = Width;
this->TargetHeight = Height;
this->TargetPixelFormats = TargetFormats;
this->TargetResizer = Resizer;
return ReAdjustOutputFormat(TargetFormats, Width, Height, Resizer, ErrorMsg, MsgSize);
}
int FFVideo::ReAdjustOutputFormat(int64_t TargetFormats, int Width, int Height, int Resizer, char *ErrorMsg, unsigned MsgSize) {
if (SWS) {
sws_freeContext(SWS);
SWS = NULL;
}
int Loss;
PixelFormat OutputFormat = avcodec_find_best_pix_fmt(TargetFormats,
CodecContext->pix_fmt, 1 /* Required to prevent pointless RGB32 => RGB24 conversion */, &Loss);
if (OutputFormat == PIX_FMT_NONE) {
ResetOutputFormat();
snprintf(ErrorMsg, MsgSize, "No suitable output format found");
return 1;
}
if (CodecContext->pix_fmt != OutputFormat || Width != CodecContext->width || Height != CodecContext->height) {
SWS = sws_getContext(CodecContext->width, CodecContext->height, CodecContext->pix_fmt, Width, Height,
OutputFormat, GetSWSCPUFlags() | Resizer, NULL, NULL, NULL);
if (SWS == NULL) {
ResetOutputFormat();
snprintf(ErrorMsg, MsgSize, "Failed to allocate SWScale context");
return 1;
}
}
VP.VPixelFormat = OutputFormat;
VP.Height = Height;
VP.Width = Width;
avpicture_free(&SWSFrame);
avpicture_alloc(&SWSFrame, OutputFormat, Width, Height);
return 0;
}
void FFVideo::ResetOutputFormat() {
if (SWS) {
sws_freeContext(SWS);
SWS = NULL;
}
TargetWidth = -1;
TargetHeight = -1;
TargetPixelFormats = 0;
VP.Height = CodecContext->height;
VP.Width = CodecContext->width;
VP.VPixelFormat = CodecContext->pix_fmt;
}

42
aegisub/libffms/ffvideosource.h → aegisub/libffms/src/core/ffvideosource.h
View file

@ -34,13 +34,14 @@ extern "C" {
#include "ffms.h"
#ifdef HAALISOURCE
# define WIN32_LEAN_AND_MEAN
# define _WIN32_DCOM
# include <windows.h>
# include <tchar.h>
# include <atlbase.h>
# include <dshow.h>
# include "CoParser.h"
# include <initguid.h>
# include "CoParser.h"
# include "guids.h"
#endif
@ -49,27 +50,37 @@ private:
pp_context_t *PPContext;
pp_mode_t *PPMode;
SwsContext *SWS;
int LastFrameHeight;
int LastFrameWidth;
PixelFormat LastFramePixelFormat;
int TargetHeight;
int TargetWidth;
int64_t TargetPixelFormats;
int TargetResizer;
AVPicture PPFrame;
AVPicture SWSFrame;
protected:
TVideoProperties VP;
FFVideoProperties VP;
FFAVFrame LocalFrame;
AVFrame *DecodeFrame;
AVFrame *PPFrame;
AVFrame *FinalFrame;
int LastFrameNum;
FFTrack Frames;
int VideoTrack;
int CurrentFrame;
AVCodecContext *CodecContext;
FFVideo();
int InitPP(const char *PP, PixelFormat PixelFormat, char *ErrorMsg, unsigned MsgSize);
TAVFrameLite *OutputFrame(AVFrame *Frame);
FFVideo(const char *SourceFile, FFIndex *Index, char *ErrorMsg, unsigned MsgSize);
int InitPP(const char *PP, char *ErrorMsg, unsigned MsgSize);
int ReAdjustPP(PixelFormat VPixelFormat, int Width, int Height, char *ErrorMsg, unsigned MsgSize);
FFAVFrame *OutputFrame(AVFrame *Frame, char *ErrorMsg, unsigned MsgSize);
public:
virtual ~FFVideo();
const TVideoProperties& GetTVideoProperties() { return VP; }
const FFVideoProperties& GetFFVideoProperties() { return VP; }
FFTrack *GetFFTrack() { return &Frames; }
virtual TAVFrameLite *GetFrame(int n, char *ErrorMsg, unsigned MsgSize) = 0;
TAVFrameLite *GetFrameByTime(double Time, char *ErrorMsg, unsigned MsgSize);
int SetOutputFormat(int64_t TargetFormats, int Width, int Height, char *ErrorMsg, unsigned MsgSize);
virtual FFAVFrame *GetFrame(int n, char *ErrorMsg, unsigned MsgSize) = 0;
FFAVFrame *GetFrameByTime(double Time, char *ErrorMsg, unsigned MsgSize);
int SetOutputFormat(int64_t TargetFormats, int Width, int Height, int Resizer, char *ErrorMsg, unsigned MsgSize);
int ReAdjustOutputFormat(int64_t TargetFormats, int Width, int Height, int Resizer, char *ErrorMsg, unsigned MsgSize);
void ResetOutputFormat();
};
@ -83,7 +94,7 @@ private:
public:
FFLAVFVideo(const char *SourceFile, int Track, FFIndex *Index, const char *PP, int Threads, int SeekMode, char *ErrorMsg, unsigned MsgSize);
~FFLAVFVideo();
TAVFrameLite *GetFrame(int n, char *ErrorMsg, unsigned MsgSize);
FFAVFrame *GetFrame(int n, char *ErrorMsg, unsigned MsgSize);
};
class FFMatroskaVideo : public FFVideo {
@ -98,7 +109,7 @@ private:
public:
FFMatroskaVideo(const char *SourceFile, int Track, FFIndex *Index, const char *PP, int Threads, char *ErrorMsg, unsigned MsgSize);
~FFMatroskaVideo();
TAVFrameLite *GetFrame(int n, char *ErrorMsg, unsigned MsgSize);
FFAVFrame *GetFrame(int n, char *ErrorMsg, unsigned MsgSize);
};
#ifdef HAALISOURCE
@ -106,14 +117,15 @@ public:
class FFHaaliVideo : public FFVideo {
private:
CComPtr<IMMContainer> pMMC;
uint8_t * CodecPrivate;
std::vector<uint8_t> CodecPrivate;
AVBitStreamFilterContext *BitStreamFilter;
void Free(bool CloseCodec);
int DecodeNextFrame(int64_t *AFirstStartTime, char *ErrorMsg, unsigned MsgSize);
public:
FFHaaliVideo(const char *SourceFile, int Track, FFIndex *Index, const char *PP, int Threads, int SourceMode, char *ErrorMsg, unsigned MsgSize);
~FFHaaliVideo();
TAVFrameLite *GetFrame(int n, char *ErrorMsg, unsigned MsgSize);
FFAVFrame *GetFrame(int n, char *ErrorMsg, unsigned MsgSize);
};
#endif // HAALISOURCE

0
aegisub/libffms/guids.h → aegisub/libffms/src/core/guids.h
View file

440
aegisub/libffms/src/core/indexing.cpp Normal file
View file

@ -0,0 +1,440 @@
// Copyright (c) 2007-2009 Fredrik Mellbin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include "indexing.h"
#include <iostream>
#include <fstream>
#include <algorithm>
#include <stdio.h>
extern "C" {
#include <libavutil/sha1.h>
}
struct IndexHeader {
uint32_t Id;
uint32_t Version;
uint32_t Tracks;
uint32_t Decoder;
uint32_t LAVUVersion;
uint32_t LAVFVersion;
uint32_t LAVCVersion;
uint32_t LSWSVersion;
uint32_t LPPVersion;
int64_t FileSize;
uint8_t FileSignature[20];
};
SharedVideoContext::SharedVideoContext(bool FreeCodecContext) {
CodecContext = NULL;
Parser = NULL;
CS = NULL;
this->FreeCodecContext = FreeCodecContext;
}
SharedVideoContext::~SharedVideoContext() {
if (CodecContext) {
avcodec_close(CodecContext);
if (FreeCodecContext)
av_freep(&CodecContext);
}
if (Parser)
av_parser_close(Parser);
if (CS)
cs_Destroy(CS);
}
SharedAudioContext::SharedAudioContext(bool FreeCodecContext) {
W64Writer = NULL;
CodecContext = NULL;
CurrentSample = 0;
CS = NULL;
this->FreeCodecContext = FreeCodecContext;
}
SharedAudioContext::~SharedAudioContext() {
delete W64Writer;
if (CodecContext) {
avcodec_close(CodecContext);
if (FreeCodecContext)
av_freep(&CodecContext);
}
if (CS)
cs_Destroy(CS);
}
TFrameInfo::TFrameInfo(int64_t DTS, int64_t SampleStart, int RepeatPict, bool KeyFrame, int64_t FilePos, unsigned int FrameSize) {
this->DTS = DTS;
this->RepeatPict = RepeatPict;
this->KeyFrame = KeyFrame;
this->SampleStart = SampleStart;
this->FilePos = FilePos;
this->FrameSize = FrameSize;
}
TFrameInfo TFrameInfo::VideoFrameInfo(int64_t DTS, int RepeatPict, bool KeyFrame, int64_t FilePos, unsigned int FrameSize) {
return TFrameInfo(DTS, 0, RepeatPict, KeyFrame, FilePos, FrameSize);
}
TFrameInfo TFrameInfo::AudioFrameInfo(int64_t DTS, int64_t SampleStart, bool KeyFrame, int64_t FilePos, unsigned int FrameSize) {
return TFrameInfo(DTS, SampleStart, 0, KeyFrame, FilePos, FrameSize);
}
int FFTrack::WriteTimecodes(const char *TimecodeFile, char *ErrorMsg, unsigned MsgSize) {
ffms_fstream Timecodes(TimecodeFile, std::ios::out | std::ios::trunc);
if (!Timecodes.is_open()) {
snprintf(ErrorMsg, MsgSize, "Failed to open '%s' for writing", TimecodeFile);
return 1;
}
Timecodes << "# timecode format v2\n";
for (iterator Cur=begin(); Cur!=end(); Cur++)
Timecodes << std::fixed << ((Cur->DTS * TB.Num) / (double)TB.Den) << "\n";
return 0;
}
int FFTrack::FrameFromDTS(int64_t DTS) {
for (int i = 0; i < static_cast<int>(size()); i++)
if (at(i).DTS == DTS)
return i;
return -1;
}
int FFTrack::ClosestFrameFromDTS(int64_t DTS) {
int Frame = 0;
int64_t BestDiff = 0xFFFFFFFFFFFFFFLL; // big number
for (int i = 0; i < static_cast<int>(size()); i++) {
int64_t CurrentDiff = FFABS(at(i).DTS - DTS);
if (CurrentDiff < BestDiff) {
BestDiff = CurrentDiff;
Frame = i;
}
}
return Frame;
}
int FFTrack::FindClosestVideoKeyFrame(int Frame) {
Frame = FFMIN(FFMAX(Frame, 0), static_cast<int>(size()) - 1);
for (int i = Frame; i > 0; i--)
if (at(i).KeyFrame)
return i;
return 0;
}
int FFTrack::FindClosestAudioKeyFrame(int64_t Sample) {
for (size_t i = 0; i < size(); i++) {
if (at(i).SampleStart == Sample && at(i).KeyFrame)
return i;
else if (at(i).SampleStart > Sample && at(i).KeyFrame)
return i - 1;
}
return size() - 1;
}
FFTrack::FFTrack() {
this->TT = FFMS_TYPE_UNKNOWN;
this->TB.Num = 0;
this->TB.Den = 0;
}
FFTrack::FFTrack(int64_t Num, int64_t Den, FFMS_TrackType TT) {
this->TT = TT;
this->TB.Num = Num;
this->TB.Den = Den;
}
int FFIndex::CalculateFileSignature(const char *Filename, int64_t *Filesize, uint8_t Digest[20], char *ErrorMsg, unsigned MsgSize) {
// use cstdio because Microsoft's implementation of std::fstream doesn't support files >4GB.
// please kill me now.
FILE *SFile = ffms_fopen(Filename,"rb");
if (SFile == NULL) {
snprintf(ErrorMsg, MsgSize, "Failed to open '%s' for hashing", Filename);
return 1;
}
const int BlockSize = 2*1024*1024;
std::vector<uint8_t> FileBuffer(BlockSize);
std::vector<uint8_t> ctxmem(av_sha1_size);
AVSHA1 *ctx = (AVSHA1 *)&ctxmem[0];
av_sha1_init(ctx);
memset(&FileBuffer[0], 0, BlockSize);
fread(&FileBuffer[0], 1, BlockSize, SFile);
if (ferror(SFile) && !feof(SFile)) {
snprintf(ErrorMsg, MsgSize, "Failed to read from '%s' for hashing", Filename);
av_sha1_final(ctx, Digest);
fclose(SFile);
return 1;
}
av_sha1_update(ctx, &FileBuffer[0], BlockSize);
fseeko(SFile, -BlockSize, SEEK_END);
memset(&FileBuffer[0], 0, BlockSize);
fread(&FileBuffer[0], 1, BlockSize, SFile);
if (ferror(SFile) && !feof(SFile)) {
snprintf(ErrorMsg, MsgSize, "Failed to seek with offset %d from file end in '%s' for hashing", BlockSize, Filename);
av_sha1_final(ctx, Digest);
fclose(SFile);
return 1;
}
av_sha1_update(ctx, &FileBuffer[0], BlockSize);
fseeko(SFile, 0, SEEK_END);
if (ferror(SFile)) {
snprintf(ErrorMsg, MsgSize, "Failed to seek to end of '%s' for hashing", Filename);
av_sha1_final(ctx, Digest);
fclose(SFile);
return 1;
}
*Filesize = ftello(SFile);
fclose(SFile);
av_sha1_final(ctx, Digest);
return 0;
}
static bool DTSComparison(TFrameInfo FI1, TFrameInfo FI2) {
return FI1.DTS < FI2.DTS;
}
void FFIndex::Sort() {
for (FFIndex::iterator Cur=begin(); Cur!=end(); Cur++)
std::sort(Cur->begin(), Cur->end(), DTSComparison);
}
int FFIndex::CompareFileSignature(const char *Filename, char *ErrorMsg, unsigned MsgSize) {
int64_t CFilesize;
uint8_t CDigest[20];
CalculateFileSignature(Filename, &CFilesize, CDigest, ErrorMsg, MsgSize);
if (CFilesize != Filesize || memcmp(CDigest, Digest, sizeof(Digest))) {
snprintf(ErrorMsg, MsgSize, "Index and source file signature mismatch");
return 1;
}
return 0;
}
int FFIndex::WriteIndex(const char *IndexFile, char *ErrorMsg, unsigned MsgSize) {
ffms_fstream IndexStream(IndexFile, std::ios::out | std::ios::binary | std::ios::trunc);
if (!IndexStream.is_open()) {
snprintf(ErrorMsg, MsgSize, "Failed to open '%s' for writing", IndexFile);
return 1;
}
// Write the index file header
IndexHeader IH;
IH.Id = INDEXID;
IH.Version = INDEXVERSION;
IH.Tracks = size();
IH.Decoder = Decoder;
IH.LAVUVersion = avutil_version();
IH.LAVFVersion = avformat_version();
IH.LAVCVersion = avcodec_version();
IH.LSWSVersion = swscale_version();
IH.LPPVersion = postproc_version();
IH.FileSize = Filesize;
memcpy(IH.FileSignature, Digest, sizeof(Digest));
IndexStream.write(reinterpret_cast<char *>(&IH), sizeof(IH));
for (unsigned int i = 0; i < IH.Tracks; i++) {
uint32_t TT = at(i).TT;
IndexStream.write(reinterpret_cast<char *>(&TT), sizeof(TT));
int64_t Num = at(i).TB.Num;
IndexStream.write(reinterpret_cast<char *>(&Num), sizeof(Num));
int64_t Den = at(i).TB.Den;
IndexStream.write(reinterpret_cast<char *>(&Den), sizeof(Den));
int64_t Frames = at(i).size();
IndexStream.write(reinterpret_cast<char *>(&Frames), sizeof(Frames));
for (FFTrack::iterator Cur=at(i).begin(); Cur!=at(i).end(); Cur++)
IndexStream.write(reinterpret_cast<char *>(&*Cur), sizeof(TFrameInfo));
}
return 0;
}
int FFIndex::ReadIndex(const char *IndexFile, char *ErrorMsg, unsigned MsgSize) {
ffms_fstream Index(IndexFile, std::ios::in | std::ios::binary);
if (!Index.is_open()) {
snprintf(ErrorMsg, MsgSize, "Failed to open '%s' for reading", IndexFile);
return 1;
}
// Read the index file header
IndexHeader IH;
Index.read(reinterpret_cast<char *>(&IH), sizeof(IH));
if (IH.Id != INDEXID) {
snprintf(ErrorMsg, MsgSize, "'%s' is not a valid index file", IndexFile);
return 2;
}
if (IH.Version != INDEXVERSION) {
snprintf(ErrorMsg, MsgSize, "'%s' is not the expected index version", IndexFile);
return 3;
}
if (IH.LAVUVersion != avutil_version() || IH.LAVFVersion != avformat_version() ||
IH.LAVCVersion != avcodec_version() || IH.LSWSVersion != swscale_version() ||
IH.LPPVersion != postproc_version()) {
snprintf(ErrorMsg, MsgSize, "A different FFmpeg build was used to create '%s'", IndexFile);
return 4;
}
Decoder = IH.Decoder;
Filesize = IH.FileSize;
memcpy(Digest, IH.FileSignature, sizeof(Digest));
try {
for (unsigned int i = 0; i < IH.Tracks; i++) {
// Read how many records belong to the current stream
uint32_t TT;
Index.read(reinterpret_cast<char *>(&TT), sizeof(TT));
int64_t Num;
Index.read(reinterpret_cast<char *>(&Num), sizeof(Num));
int64_t Den;
Index.read(reinterpret_cast<char *>(&Den), sizeof(Den));
int64_t Frames;
Index.read(reinterpret_cast<char *>(&Frames), sizeof(Frames));
push_back(FFTrack(Num, Den, static_cast<FFMS_TrackType>(TT)));
TFrameInfo FI = TFrameInfo::VideoFrameInfo(0, 0, false);
for (size_t j = 0; j < Frames; j++) {
Index.read(reinterpret_cast<char *>(&FI), sizeof(TFrameInfo));
at(i).push_back(FI);
}
}
} catch (...) {
snprintf(ErrorMsg, MsgSize, "Unknown error while reading index information in '%s'", IndexFile);
return 5;
}
return 0;
}
FFIndex::FFIndex() {
// this comment documents nothing
}
FFIndex::FFIndex(int64_t Filesize, uint8_t Digest[20]) {
this->Filesize = Filesize;
memcpy(this->Digest, Digest, sizeof(this->Digest));
}
void FFIndexer::SetIndexMask(int IndexMask) {
this->IndexMask = IndexMask;
}
void FFIndexer::SetDumpMask(int DumpMask) {
this->DumpMask = DumpMask;
}
void FFIndexer::SetIgnoreDecodeErrors(bool IgnoreDecodeErrors) {
this->IgnoreDecodeErrors = IgnoreDecodeErrors;
}
void FFIndexer::SetProgressCallback(TIndexCallback IC, void *ICPrivate) {
this->IC = IC;
this->ICPrivate = ICPrivate;
}
void FFIndexer::SetAudioNameCallback(TAudioNameCallback ANC, void *ANCPrivate) {
this->ANC = ANC;
this->ANCPrivate = ANCPrivate;
}
FFIndexer *FFIndexer::CreateFFIndexer(const char *Filename, char *ErrorMsg, unsigned MsgSize) {
AVFormatContext *FormatContext = NULL;
if (av_open_input_file(&FormatContext, Filename, NULL, 0, NULL) != 0) {
snprintf(ErrorMsg, MsgSize, "Can't open '%s'", Filename);
return NULL;
}
// Do matroska indexing instead?
if (!strcmp(FormatContext->iformat->name, "matroska")) {
av_close_input_file(FormatContext);
return new FFMatroskaIndexer(Filename, ErrorMsg, MsgSize);
}
#ifdef HAALISOURCE
// Do haali ts indexing instead?
if (!strcmp(FormatContext->iformat->name, "mpeg") || !strcmp(FormatContext->iformat->name, "mpegts")) {
av_close_input_file(FormatContext);
return new FFHaaliIndexer(Filename, 0, ErrorMsg, MsgSize);
}
if (!strcmp(FormatContext->iformat->name, "ogg")) {
av_close_input_file(FormatContext);
return new FFHaaliIndexer(Filename, 1, ErrorMsg, MsgSize);
}
#endif
return new FFLAVFIndexer(Filename, FormatContext, ErrorMsg, MsgSize);
}
FFIndexer::FFIndexer(const char *Filename, char *ErrorMsg, unsigned MsgSize) : DecodingBuffer(AVCODEC_MAX_AUDIO_FRAME_SIZE * 5) {
if (FFIndex::CalculateFileSignature(Filename, &Filesize, Digest, ErrorMsg, MsgSize))
throw ErrorMsg;
}
FFIndexer::~FFIndexer() {
}
bool FFIndexer::WriteAudio(SharedAudioContext &AudioContext, FFIndex *Index, int Track, int DBSize, char *ErrorMsg, unsigned MsgSize) {
// Delay writer creation until after an audio frame has been decoded. This ensures that all parameters are known when writing the headers.
if (DBSize > 0) {
if (!AudioContext.W64Writer) {
FFAudioProperties AP;
FillAP(AP, AudioContext.CodecContext, (*Index)[Track]);
int FNSize = (*ANC)(SourceFile, Track, &AP, NULL, 0, ANCPrivate);
std::vector<char> WName(FNSize);
(*ANC)(SourceFile, Track, &AP, &WName[0], FNSize, ANCPrivate);
std::string WN(&WName[0]);
try {
AudioContext.W64Writer = new Wave64Writer(WN.c_str(), av_get_bits_per_sample_format(AudioContext.CodecContext->sample_fmt),
AudioContext.CodecContext->channels, AudioContext.CodecContext->sample_rate, (AudioContext.CodecContext->sample_fmt == SAMPLE_FMT_FLT) || (AudioContext.CodecContext->sample_fmt == SAMPLE_FMT_DBL));
} catch (...) {
snprintf(ErrorMsg, MsgSize, "Failed to write wave data");
return false;
}
}
AudioContext.W64Writer->WriteData(&DecodingBuffer[0], DBSize);
}
return true;
}

140
aegisub/libffms/indexing.h → aegisub/libffms/src/core/indexing.h
View file

@ -21,39 +21,93 @@
#ifndef INDEXING_H
#define INDEXING_H
#include <memory>
#include "utils.h"
#include "wave64writer.h"
#define INDEXVERSION 26
#ifdef HAALISOURCE
# define WIN32_LEAN_AND_MEAN
# define _WIN32_DCOM
# include <windows.h>
# include <tchar.h>
# include <atlbase.h>
# include <dshow.h>
# include <initguid.h>
# include "CoParser.h"
# include "guids.h"
#endif
#define INDEXVERSION 28
#define INDEXID 0x53920873
struct IndexHeader {
uint32_t Id;
uint32_t Version;
uint32_t Tracks;
uint32_t Decoder;
uint32_t LAVUVersion;
uint32_t LAVFVersion;
uint32_t LAVCVersion;
uint32_t LSWSVersion;
uint32_t LPPVersion;
class SharedVideoContext {
private:
bool FreeCodecContext;
public:
AVCodecContext *CodecContext;
AVCodecParserContext *Parser;
CompressedStream *CS;
SharedVideoContext(bool FreeCodecContext);
~SharedVideoContext();
};
class SharedAudioContext {
private:
bool FreeCodecContext;
public:
Wave64Writer *W64W;
AVCodecContext *CTX;
AVCodecContext *CodecContext;
Wave64Writer *W64Writer;
int64_t CurrentSample;
CompressedStream *CS;
SharedAudioContext() {
W64W = NULL;
CTX = NULL;
CurrentSample = 0;
}
SharedAudioContext(bool FreeCodecContext);
~SharedAudioContext();
};
~SharedAudioContext() {
delete W64W;
}
struct TFrameInfo {
public:
FFMS_FRAMEINFO_COMMON
int64_t SampleStart;
int64_t FilePos;
unsigned int FrameSize;
static TFrameInfo VideoFrameInfo(int64_t DTS, int RepeatPict, bool KeyFrame, int64_t FilePos = 0, unsigned int FrameSize = 0);
static TFrameInfo AudioFrameInfo(int64_t DTS, int64_t SampleStart, bool KeyFrame, int64_t FilePos = 0, unsigned int FrameSize = 0);
private:
TFrameInfo(int64_t DTS, int64_t SampleStart, int RepeatPict, bool KeyFrame, int64_t FilePos, unsigned int FrameSize);
};
class FFTrack : public std::vector<TFrameInfo> {
public:
FFMS_TrackType TT;
FFTrackTimeBase TB;
int FindClosestVideoKeyFrame(int Frame);
int FindClosestAudioKeyFrame(int64_t Sample);
int FrameFromDTS(int64_t DTS);
int ClosestFrameFromDTS(int64_t DTS);
int WriteTimecodes(const char *TimecodeFile, char *ErrorMsg, unsigned MsgSize);
FFTrack();
FFTrack(int64_t Num, int64_t Den, FFMS_TrackType TT);
};
class FFIndex : public std::vector<FFTrack> {
public:
static int CalculateFileSignature(const char *Filename, int64_t *Filesize, uint8_t Digest[20], char *ErrorMsg, unsigned MsgSize);
int Decoder;
int64_t Filesize;
uint8_t Digest[20];
void Sort();
int CompareFileSignature(const char *Filename, char *ErrorMsg, unsigned MsgSize);
int WriteIndex(const char *IndexFile, char *ErrorMsg, unsigned MsgSize);
int ReadIndex(const char *IndexFile, char *ErrorMsg, unsigned MsgSize);
FFIndex();
FFIndex(int64_t Filesize, uint8_t Digest[20]);
};
class FFIndexer {
@ -66,18 +120,21 @@ protected:
TAudioNameCallback ANC;
void *ANCPrivate;
const char *SourceFile;
int16_t *DecodingBuffer;
std::vector<int16_t> DecodingBuffer;
int64_t Filesize;
uint8_t Digest[20];
bool WriteAudio(SharedAudioContext &AudioContext, FFIndex *Index, int Track, int DBSize, char *ErrorMsg, unsigned MsgSize);
public:
static FFIndexer *CreateFFIndexer(const char *Filename, char *ErrorMsg, unsigned MsgSize);
FFIndexer();
FFIndexer(const char *Filename, char *ErrorMsg, unsigned MsgSize);
virtual ~FFIndexer();
void SetIndexMask(int IndexMask) { this->IndexMask = IndexMask; }
void SetDumpMask(int DumpMask) { this->DumpMask = DumpMask; }
void SetIgnoreDecodeErrors(bool IgnoreDecodeErrors) { this->IgnoreDecodeErrors = IgnoreDecodeErrors; }
void SetProgressCallback(TIndexCallback IC, void *ICPrivate) { this->IC = IC; this->ICPrivate = ICPrivate; }
void SetAudioNameCallback(TAudioNameCallback ANC, void *ANCPrivate) { this->ANC = ANC; this->ANCPrivate = ANCPrivate; }
void SetIndexMask(int IndexMask);
void SetDumpMask(int DumpMask);
void SetIgnoreDecodeErrors(bool IgnoreDecodeErrors);
void SetProgressCallback(TIndexCallback IC, void *ICPrivate);
void SetAudioNameCallback(TAudioNameCallback ANC, void *ANCPrivate);
virtual FFIndex *DoIndexing(char *ErrorMsg, unsigned MsgSize) = 0;
virtual int GetNumberOfTracks() = 0;
virtual FFMS_TrackType GetTrackType(int Track) = 0;
@ -86,17 +143,14 @@ public:
class FFLAVFIndexer : public FFIndexer {
private:
bool IsIndexing;
AVFormatContext *FormatContext;
public:
FFLAVFIndexer(const char *Filename, AVFormatContext *FormatContext, char *ErrorMsg, unsigned MsgSize);
~FFLAVFIndexer();
FFIndex *DoIndexing(char *ErrorMsg, unsigned MsgSize);
int GetNumberOfTracks() { return FormatContext->nb_streams; }
FFMS_TrackType GetTrackType(int Track) { return static_cast<FFMS_TrackType>(FormatContext->streams[Track]->codec->codec_type); }
const char *GetTrackCodec(int Track) {
return (avcodec_find_decoder(FormatContext->streams[Track]->codec->codec_id))->long_name;
}
int GetNumberOfTracks();
FFMS_TrackType GetTrackType(int Track);
const char *GetTrackCodec(int Track);
};
class FFMatroskaIndexer : public FFIndexer {
@ -106,10 +160,11 @@ private:
AVCodec *Codec[32];
public:
FFMatroskaIndexer(const char *Filename, char *ErrorMsg, unsigned MsgSize);
~FFMatroskaIndexer();
FFIndex *DoIndexing(char *ErrorMsg, unsigned MsgSize);
int GetNumberOfTracks() { return mkv_GetNumTracks(MF); }
FFMS_TrackType GetTrackType(int Track) { return HaaliTrackTypeToFFTrackType(mkv_GetTrackInfo(MF, Track)->Type); }
const char *GetTrackCodec(int Track) { if (Codec[Track]) return Codec[Track]->long_name; else return "Unsupported codec/Unknown codec name"; }
int GetNumberOfTracks();
FFMS_TrackType GetTrackType(int Track);
const char *GetTrackCodec(int Track);
};
#ifdef HAALISOURCE
@ -121,15 +176,16 @@ private:
int NumTracks;
FFMS_TrackType TrackType[32];
AVCodec *Codec[32];
uint8_t *CodecPrivate[32];
std::vector<uint8_t> CodecPrivate[32];
int CodecPrivateSize[32];
CComQIPtr<IPropertyBag> PropertyBags[32];
int64_t Duration;
public:
FFHaaliIndexer(const char *Filename, int SourceMode, char *ErrorMsg, unsigned MsgSize);
~FFHaaliIndexer() { for (int i = 0; i < 32; i++) delete[] CodecPrivate[i]; }
FFIndex *DoIndexing(char *ErrorMsg, unsigned MsgSize);
int GetNumberOfTracks() { return NumTracks; }
FFMS_TrackType GetTrackType(int Track) { return TrackType[Track]; }
const char *GetTrackCodec(int Track) { if (Codec[Track]) return Codec[Track]->long_name; else return "Unsupported codec/Unknown codec name"; }
int GetNumberOfTracks();
FFMS_TrackType GetTrackType(int Track);
const char *GetTrackCodec(int Track);
};
#endif // HAALISOURCE

4
aegisub/libffms/MatroskaParser.c → aegisub/libffms/src/core/matroskaparser.c
View file

@ -45,7 +45,7 @@
#define EVCBUG
#endif
#include "MatroskaParser.h"
#include "matroskaparser.h"
#ifdef MATROSKA_COMPRESSION_SUPPORT
#include <zlib.h>
@ -65,7 +65,7 @@
#define MAXCLUSTER (64*1048576)
#define MAXFRAME (4*1048576)
#ifdef WIN32
#ifdef _MSC_VER
#define LL(x) x##i64
#define ULL(x) x##ui64
#else

0
aegisub/libffms/MatroskaParser.h → aegisub/libffms/src/core/matroskaparser.h
View file

21
aegisub/libffms/stdiostream.c → aegisub/libffms/src/core/stdiostream.c
View file

@ -19,14 +19,9 @@
// THE SOFTWARE.
#include "stdiostream.h"
#include "ffmscompat.h"
#include <errno.h>
#ifdef __UNIX__
#define _fseeki64 fseeko
#define _ftelli64 ftello
#endif
/* StdIoStream methods */
/* read count bytes into buffer starting at file position pos
@ -34,7 +29,7 @@
*/
int StdIoRead(StdIoStream *st, ulonglong pos, void *buffer, int count) {
size_t rd;
if (_fseeki64(st->fp, pos, SEEK_SET)) {
if (fseeko(st->fp, pos, SEEK_SET)) {
st->error = errno;
return -1;
}
@ -56,13 +51,13 @@ longlong StdIoScan(StdIoStream *st, ulonglong start, unsigned signature) {
unsigned cmp = 0;
FILE *fp = st->fp;
if (_fseeki64(fp, start, SEEK_SET))
if (fseeko(fp, start, SEEK_SET))
return -1;
while ((c = getc(fp)) != EOF) {
cmp = ((cmp << 8) | c) & 0xffffffff;
if (cmp == signature)
return _ftelli64(fp) - 4;
return ftello(fp) - 4;
}
return -1;
@ -100,10 +95,10 @@ int StdIoProgress(StdIoStream *st, ulonglong cur, ulonglong max) {
longlong StdIoGetFileSize(StdIoStream *st) {
longlong epos = 0;
longlong cpos = _ftelli64(st->fp);
_fseeki64(st->fp, 0, SEEK_END);
epos = _ftelli64(st->fp);
_fseeki64(st->fp, cpos, SEEK_SET);
longlong cpos = ftello(st->fp);
fseeko(st->fp, 0, SEEK_END);
epos = ftello(st->fp);
fseeko(st->fp, cpos, SEEK_SET);
return epos;
}

2
aegisub/libffms/stdiostream.h → aegisub/libffms/src/core/stdiostream.h
View file

@ -24,7 +24,7 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "MatroskaParser.h"
#include "matroskaparser.h"
#define CACHESIZE 65536

364
aegisub/libffms/src/core/utils.cpp Normal file
View file

@ -0,0 +1,364 @@
// Copyright (c) 2007-2009 Fredrik Mellbin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include <string.h>
#include <errno.h>
#include "utils.h"
#include "indexing.h"
#ifdef FFMS_USE_UTF8_PATHS
# define WIN32_LEAN_AND_MEAN
# include <windows.h>
#endif
// Export the array but not its data type... fun...
typedef struct CodecTags{
char str[20];
enum CodecID id;
} CodecTags;
extern "C" {
extern const AVCodecTag ff_codec_bmp_tags[];
extern const CodecTags ff_mkv_codec_tags[];
extern const AVCodecTag ff_codec_movvideo_tags[];
extern const AVCodecTag ff_codec_wav_tags[];
}
extern int CPUFeatures;
int GetSWSCPUFlags() {
int Flags = 0;
if (CPUFeatures & FFMS_CPU_CAPS_MMX)
Flags |= SWS_CPU_CAPS_MMX;
if (CPUFeatures & FFMS_CPU_CAPS_MMX2)
Flags |= SWS_CPU_CAPS_MMX2;
if (CPUFeatures & FFMS_CPU_CAPS_3DNOW)
Flags |= SWS_CPU_CAPS_3DNOW;
if (CPUFeatures & FFMS_CPU_CAPS_ALTIVEC)
Flags |= SWS_CPU_CAPS_ALTIVEC;
if (CPUFeatures & FFMS_CPU_CAPS_BFIN)
Flags |= SWS_CPU_CAPS_BFIN;
return Flags;
}
int GetPPCPUFlags() {
int Flags = 0;
if (CPUFeatures & FFMS_CPU_CAPS_MMX)
Flags |= PP_CPU_CAPS_MMX;
if (CPUFeatures & FFMS_CPU_CAPS_MMX2)
Flags |= PP_CPU_CAPS_MMX2;
if (CPUFeatures & FFMS_CPU_CAPS_3DNOW)
Flags |= PP_CPU_CAPS_3DNOW;
if (CPUFeatures & FFMS_CPU_CAPS_ALTIVEC)
Flags |= PP_CPU_CAPS_ALTIVEC;
return Flags;
}
FFMS_TrackType HaaliTrackTypeToFFTrackType(int TT) {
switch (TT) {
case TT_VIDEO: return FFMS_TYPE_VIDEO; break;
case TT_AUDIO: return FFMS_TYPE_AUDIO; break;
case TT_SUB: return FFMS_TYPE_SUBTITLE; break;
default: return FFMS_TYPE_UNKNOWN;
}
}
int ReadFrame(uint64_t FilePos, unsigned int &FrameSize, CompressedStream *CS, MatroskaReaderContext &Context, char *ErrorMsg, unsigned MsgSize) {
if (CS) {
char CSBuffer[4096];
unsigned int DecompressedFrameSize = 0;
cs_NextFrame(CS, FilePos, FrameSize);
for (;;) {
int ReadBytes = cs_ReadData(CS, CSBuffer, sizeof(CSBuffer));
if (ReadBytes < 0) {
snprintf(ErrorMsg, MsgSize, "Error decompressing data: %s", cs_GetLastError(CS));
return 1;
}
if (ReadBytes == 0) {
FrameSize = DecompressedFrameSize;
return 0;
}
if (Context.BufferSize < DecompressedFrameSize + ReadBytes) {
Context.BufferSize = FrameSize;
Context.Buffer = (uint8_t *)realloc(Context.Buffer, Context.BufferSize + 16);
if (Context.Buffer == NULL) {
snprintf(ErrorMsg, MsgSize, "Out of memory");
return 2;
}
}
memcpy(Context.Buffer + DecompressedFrameSize, CSBuffer, ReadBytes);
DecompressedFrameSize += ReadBytes;
}
} else {
if (fseeko(Context.ST.fp, FilePos, SEEK_SET)) {
snprintf(ErrorMsg, MsgSize, "fseek(): %s", strerror(errno));
return 3;
}
if (Context.BufferSize < FrameSize) {
Context.BufferSize = FrameSize;
Context.Buffer = (uint8_t *)realloc(Context.Buffer, Context.BufferSize + 16);
if (Context.Buffer == NULL) {
snprintf(ErrorMsg, MsgSize, "Out of memory");
return 4;
}
}
size_t ReadBytes = fread(Context.Buffer, 1, FrameSize, Context.ST.fp);
if (ReadBytes != FrameSize) {
if (ReadBytes == 0) {
if (feof(Context.ST.fp)) {
snprintf(ErrorMsg, MsgSize, "Unexpected EOF while reading frame");
return 5;
} else {
snprintf(ErrorMsg, MsgSize, "Error reading frame: %s", strerror(errno));
return 6;
}
} else {
snprintf(ErrorMsg, MsgSize, "Short read while reading frame");
return 7;
}
snprintf(ErrorMsg, MsgSize, "Unknown read error");
return 8;
}
return 0;
}
}
void InitNullPacket(AVPacket *pkt) {
av_init_packet(pkt);
pkt->data = NULL;
pkt->size = 0;
}
void FillAP(FFAudioProperties &AP, AVCodecContext *CTX, FFTrack &Frames) {
AP.SampleFormat = static_cast<FFMS_SampleFormat>(CTX->sample_fmt);
AP.BitsPerSample = av_get_bits_per_sample_format(CTX->sample_fmt);
if (CTX->sample_fmt == SAMPLE_FMT_S32)
AP.BitsPerSample = CTX->bits_per_raw_sample;
AP.Channels = CTX->channels;;
AP.ChannelLayout = CTX->channel_layout;
AP.SampleRate = CTX->sample_rate;
AP.NumSamples = (Frames.back()).SampleStart;
AP.FirstTime = ((Frames.front().DTS * Frames.TB.Num) / (double)Frames.TB.Den) / 1000;
AP.LastTime = ((Frames.back().DTS * Frames.TB.Num) / (double)Frames.TB.Den) / 1000;
}
#ifdef HAALISOURCE
unsigned vtSize(VARIANT &vt) {
if (V_VT(&vt) != (VT_ARRAY | VT_UI1))
return 0;
long lb,ub;
if (FAILED(SafeArrayGetLBound(V_ARRAY(&vt),1,&lb)) ||
FAILED(SafeArrayGetUBound(V_ARRAY(&vt),1,&ub)))
return 0;
return ub - lb + 1;
}
void vtCopy(VARIANT& vt,void *dest) {
unsigned sz = vtSize(vt);
if (sz > 0) {
void *vp;
if (SUCCEEDED(SafeArrayAccessData(V_ARRAY(&vt),&vp))) {
memcpy(dest,vp,sz);
SafeArrayUnaccessData(V_ARRAY(&vt));
}
}
}
#else
// used for matroska<->ffmpeg codec ID mapping to avoid Win32 dependency
typedef struct BITMAPINFOHEADER {
uint32_t biSize;
int32_t biWidth;
int32_t biHeight;
uint16_t biPlanes;
uint16_t biBitCount;
uint32_t biCompression;
uint32_t biSizeImage;
int32_t biXPelsPerMeter;
int32_t biYPelsPerMeter;
uint32_t biClrUsed;
uint32_t biClrImportant;
} BITMAPINFOHEADER;
#define MAKEFOURCC(ch0, ch1, ch2, ch3)\
((uint32_t)(uint8_t)(ch0) | ((uint32_t)(uint8_t)(ch1) << 8) |\
((uint32_t)(uint8_t)(ch2) << 16) | ((uint32_t)(uint8_t)(ch3) << 24 ))
#endif
CodecID MatroskaToFFCodecID(char *Codec, void *CodecPrivate, unsigned int FourCC) {
/* Look up native codecs */
for(int i = 0; ff_mkv_codec_tags[i].id != CODEC_ID_NONE; i++){
if(!strncmp(ff_mkv_codec_tags[i].str, Codec,
strlen(ff_mkv_codec_tags[i].str))){
return ff_mkv_codec_tags[i].id;
}
}
/* Video codecs for "avi in mkv" mode */
const AVCodecTag *const tags[] = { ff_codec_bmp_tags, 0 };
if (!strcmp(Codec, "V_MS/VFW/FOURCC")) {
BITMAPINFOHEADER *b = reinterpret_cast<BITMAPINFOHEADER *>(CodecPrivate);
return av_codec_get_id(tags, b->biCompression);
}
if (!strcmp(Codec, "V_FOURCC")) {
return av_codec_get_id(tags, FourCC);
}
// FIXME
/* Audio codecs for "acm in mkv" mode */
//#include "Mmreg.h"
//((WAVEFORMATEX *)TI->CodecPrivate)->wFormatTag
/* Fixup for uncompressed video formats */
/* Fixup for uncompressed audio formats */
return CODEC_ID_NONE;
}
void InitializeCodecContextFromMatroskaTrackInfo(TrackInfo *TI, AVCodecContext *CodecContext) {
CodecContext->extradata = static_cast<uint8_t *>(TI->CodecPrivate);
CodecContext->extradata_size = TI->CodecPrivateSize;
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;
}
}
#ifdef HAALISOURCE
void InitializeCodecContextFromHaaliInfo(CComQIPtr<IPropertyBag> pBag, AVCodecContext *CodecContext) {
if (pBag) {
CComVariant pV;
pV.Clear();
if (SUCCEEDED(pBag->Read(L"Type", &pV, NULL)) && SUCCEEDED(pV.ChangeType(VT_UI4))) {
unsigned int TT = pV.uintVal;
if (TT == TT_VIDEO) {
pV.Clear();
if (SUCCEEDED(pBag->Read(L"Video.PixelWidth", &pV, NULL)) && SUCCEEDED(pV.ChangeType(VT_UI4)))
CodecContext->coded_width = pV.uintVal;
pV.Clear();
if (SUCCEEDED(pBag->Read(L"Video.PixelHeight", &pV, NULL)) && SUCCEEDED(pV.ChangeType(VT_UI4)))
CodecContext->coded_height = pV.uintVal;
} else if (TT == TT_AUDIO) {
pV.Clear();
if (SUCCEEDED(pBag->Read(L"Audio.SamplingFreq", &pV, NULL)) && SUCCEEDED(pV.ChangeType(VT_UI4)))
CodecContext->sample_rate = pV.uintVal;
pV.Clear();
if (SUCCEEDED(pBag->Read(L"Audio.BitDepth", &pV, NULL)) && SUCCEEDED(pV.ChangeType(VT_UI4)))
CodecContext->bits_per_coded_sample = pV.uintVal;
pV.Clear();
if (SUCCEEDED(pBag->Read(L"Audio.Channels", &pV, NULL)) && SUCCEEDED(pV.ChangeType(VT_UI4)))
CodecContext->channels = pV.uintVal;
}
}
}
}
#endif
FILE *ffms_fopen(const char *filename, const char *mode) {
#ifdef FFMS_USE_UTF8_PATHS
// Hack: support utf8-in-char* filenames on windows
wchar_t filename_wide[MAX_PATH*2];
// 64 characters of mode string ought to be more than enough for everyone
wchar_t mode_wide[64];
if ((MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, filename, -1, filename_wide, MAX_PATH) > 0)
&& (MultiByteToWideChar(CP_ACP, NULL, mode, -1, mode_wide, 60) > 0))
return _wfopen(filename_wide, mode_wide);
else
return fopen(filename, mode);
#else
return fopen(filename, mode);
#endif
}
size_t ffms_mbstowcs (wchar_t *wcstr, const char *mbstr, size_t max) {
#ifdef FFMS_USE_UTF8_PATHS
// try utf8 first
int len = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, mbstr, -1, NULL, 0);
if (len > 0) {
MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, mbstr, -1, wcstr, max);
return static_cast<size_t>(len);
}
// failed, use local ANSI codepage
else {
len = MultiByteToWideChar(CP_ACP, NULL, mbstr, -1, wcstr, max);
return static_cast<size_t>(len);
}
#else
return mbstowcs(wcstr, mbstr, max);
#endif
}
// ffms_fstream stuff
void ffms_fstream::open(const char *filename, std::ios_base::openmode mode) {
#ifdef FFMS_USE_UTF8_PATHS
// Hack: support utf8-in-char* filenames on windows
wchar_t filename_wide[MAX_PATH*2];
if (MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, filename, -1, filename_wide, MAX_PATH) > 0)
std::fstream::open(filename_wide, mode);
else
std::fstream::open(filename, mode);
#else
std::fstream::open(filename, mode);
#endif
}
ffms_fstream::ffms_fstream(const char *filename, std::ios_base::openmode mode) {
open(filename, mode);
}

77
aegisub/libffms/utils.h → aegisub/libffms/src/core/utils.h
View file

@ -21,76 +21,40 @@
#ifndef UTILS_H
#define UTILS_H
#include "ffms.h"
#include <vector>
#include <fstream>
#include <stdio.h>
#include "ffms.h"
#include "matroskaparser.h"
extern "C" {
#include "stdiostream.h"
#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include <libswscale/swscale.h>
#include <libpostproc/postprocess.h>
#include <libavutil/sha1.h>
#include "MatroskaParser.h"
#include "stdiostream.h"
}
// must be included after ffmpeg headers
#include "ffmscompat.h"
#ifdef HAALISOURCE
# define WIN32_LEAN_AND_MEAN
# define _WIN32_DCOM
# include <windows.h>
# include <tchar.h>
# include <atlbase.h>
# include <dshow.h>
# include "CoParser.h"
# include <initguid.h>
# include "CoParser.h"
# include "guids.h"
#endif
// Compatibility with older/newer ffmpegs
#if (LIBAVFORMAT_VERSION_INT) > (AV_VERSION_INT(52,34,0))
#define codec_bmp_tags ff_codec_bmp_tags
#define codec_movvideo_tags ff_codec_movvideo_tags
#define codec_wav_tags ff_codec_wav_tags
#endif
#ifndef AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY PKT_FLAG_KEY
#endif
#define FFMS_GET_VECTOR_PTR(v) (((v).size() ? &(v)[0] : NULL))
struct TFrameInfo {
FFMS_FRAMEINFO_COMMON
int64_t SampleStart;
int64_t FilePos;
unsigned int FrameSize;
#ifdef FFMS_EXPORTS
TFrameInfo(int64_t DTS, bool KeyFrame);
TFrameInfo(int64_t DTS, int64_t FilePos, unsigned int FrameSize, bool KeyFrame);
TFrameInfo(int64_t DTS, int64_t SampleStart, bool KeyFrame);
TFrameInfo(int64_t DTS, int64_t SampleStart, int64_t FilePos, unsigned int FrameSize, bool KeyFrame);
#endif
};
class FFTrack : public std::vector<TFrameInfo> {
public:
FFMS_TrackType TT;
TTrackTimeBase TB;
int FindClosestVideoKeyFrame(int Frame);
int FindClosestAudioKeyFrame(int64_t Sample);
int FrameFromDTS(int64_t DTS);
int ClosestFrameFromDTS(int64_t DTS);
int WriteTimecodes(const char *TimecodeFile, char *ErrorMsg, unsigned MsgSize);
FFTrack();
FFTrack(int64_t Num, int64_t Den, FFMS_TrackType TT);
};
class FFIndex : public std::vector<FFTrack> {
public:
int Decoder;
int WriteIndex(const char *IndexFile, char *ErrorMsg, unsigned MsgSize);
int ReadIndex(const char *IndexFile, char *ErrorMsg, unsigned MsgSize);
};
const int64_t ffms_av_nopts_value = static_cast<int64_t>(1) << 63;
struct MatroskaReaderContext {
public:
@ -109,16 +73,27 @@ public:
}
};
int GetCPUFlags();
class ffms_fstream : public std::fstream {
public:
void open(const char *filename, std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out);
ffms_fstream(const char *filename, std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out);
};
int GetSWSCPUFlags();
int GetPPCPUFlags();
FFMS_TrackType HaaliTrackTypeToFFTrackType(int TT);
int ReadFrame(uint64_t FilePos, unsigned int &FrameSize, CompressedStream *CS, MatroskaReaderContext &Context, char *ErrorMsg, unsigned MsgSize);
bool AudioFMTIsFloat(SampleFormat FMT);
void InitNullPacket(AVPacket *pkt);
void FillAP(TAudioProperties &AP, AVCodecContext *CTX, FFTrack &Frames);
void FillAP(FFAudioProperties &AP, AVCodecContext *CTX, FFTrack &Frames);
#ifdef HAALISOURCE
unsigned vtSize(VARIANT &vt);
void vtCopy(VARIANT& vt,void *dest);
void InitializeCodecContextFromHaaliInfo(CComQIPtr<IPropertyBag> pBag, AVCodecContext *CodecContext);
#endif
CodecID MatroskaToFFCodecID(char *Codec, void *CodecPrivate);
void InitializeCodecContextFromMatroskaTrackInfo(TrackInfo *TI, AVCodecContext *CodecContext);
CodecID MatroskaToFFCodecID(char *Codec, void *CodecPrivate, unsigned int FourCC = 0);
FILE *ffms_fopen(const char *filename, const char *mode);
size_t ffms_mbstowcs (wchar_t *wcstr, const char *mbstr, size_t max);
#endif

16
aegisub/libffms/wave64writer.cpp → aegisub/libffms/src/core/wave64writer.cpp
View file

@ -44,14 +44,14 @@ static const uint8_t Guiddata[16]={
0x64, 0x61, 0x74, 0x61, 0xF3, 0xAC, 0xD3, 0x11, 0x8C, 0xD1, 0x00, 0xC0, 0x4F, 0x8E, 0xDB, 0x8A
};
Wave64Writer::Wave64Writer(const char *Filename, uint16_t BitsPerSample, uint16_t Channels, uint32_t SamplesPerSec, bool IsFloat) : std::ofstream(Filename, std::ios::out | std::ios::binary | std::ios::trunc) {
Wave64Writer::Wave64Writer(const char *Filename, uint16_t BitsPerSample, uint16_t Channels, uint32_t SamplesPerSec, bool IsFloat) : WavFile(Filename, std::ios::out | std::ios::binary | std::ios::trunc) {
BytesWritten = 0;
this->BitsPerSample = BitsPerSample;
this->Channels = Channels;
this->SamplesPerSec = SamplesPerSec;
this->IsFloat = IsFloat;
if (!is_open())
if (!WavFile.is_open())
throw "Failed to open destination file for writing";
WriteHeader(true, IsFloat);
@ -59,7 +59,7 @@ Wave64Writer::Wave64Writer(const char *Filename, uint16_t BitsPerSample, uint16_
Wave64Writer::~Wave64Writer() {
WriteHeader(false, IsFloat);
close();
WavFile.close();
}
void Wave64Writer::WriteHeader(bool Initial, bool IsFloat) {
@ -99,14 +99,14 @@ void Wave64Writer::WriteHeader(bool Initial, bool IsFloat) {
else
Header[13] = BytesWritten + 24;
std::ios::streampos CPos = tellp();
seekp(0, std::ios::beg);
write(reinterpret_cast<const char *>(Header), sizeof(Header));
std::streampos CPos = WavFile.tellp();
WavFile.seekp(0, std::ios::beg);
WavFile.write(reinterpret_cast<const char *>(Header), sizeof(Header));
if (!Initial)
seekp(CPos, std::ios::beg);
WavFile.seekp(CPos, std::ios::beg);
}
void Wave64Writer::WriteData(void *Data, std::streamsize Length) {
write(reinterpret_cast<char *>(Data), Length);
WavFile.write(reinterpret_cast<char *>(Data), Length);
BytesWritten += Length;
}

4
aegisub/libffms/wave64writer.h → aegisub/libffms/src/core/wave64writer.h
View file

@ -24,6 +24,7 @@
#include <stdint.h>
#include <iostream>
#include <fstream>
#include "utils.h"
// this is to avoid depending on windows.h etc.
typedef struct FFMS_WAVEFORMATEX {
@ -36,12 +37,13 @@ typedef struct FFMS_WAVEFORMATEX {
uint16_t cbSize;
} FFMS_WAVEFORMATEX;
class Wave64Writer : private std::ofstream {
class Wave64Writer {
public:
Wave64Writer(const char *Filename, uint16_t BitsPerSample, uint16_t Channels, uint32_t SamplesPerSec, bool IsFloat);
~Wave64Writer();
void WriteData(void *Data, std::streamsize Length);
private:
ffms_fstream WavFile;
int32_t BitsPerSample;
int32_t Channels;
uint32_t SamplesPerSec;

438
aegisub/libffms/utils.cpp
View file

@ -1,438 +0,0 @@
// Copyright (c) 2007-2009 Fredrik Mellbin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include "utils.h"
#include "indexing.h"
#include <string.h>
#include <errno.h>
#include <iostream>
#include <fstream>
#ifdef _MSC_VER
# include <intrin.h>
#endif
// Export the array but not its data type... fun...
typedef struct CodecTags{
char str[20];
enum CodecID id;
} CodecTags;
extern "C" {
extern const AVCodecTag codec_bmp_tags[];
extern const CodecTags ff_mkv_codec_tags[];
extern const AVCodecTag codec_movvideo_tags[];
extern const AVCodecTag codec_wav_tags[];
}
#ifdef __UNIX__
#define _fseeki64 fseeko
#define _ftelli64 ftello
#define _snprintf snprintf
#endif
TFrameInfo::TFrameInfo(int64_t DTS, bool KeyFrame) {
this->DTS = DTS;
this->KeyFrame = KeyFrame;
this->SampleStart = 0;
this->FilePos = 0;
this->FrameSize = 0;
}
TFrameInfo::TFrameInfo(int64_t DTS, int64_t FilePos, unsigned int FrameSize, bool KeyFrame) {
this->DTS = DTS;
this->KeyFrame = KeyFrame;
this->SampleStart = 0;
this->FilePos = FilePos;
this->FrameSize = FrameSize;
}
TFrameInfo::TFrameInfo(int64_t DTS, int64_t SampleStart, bool KeyFrame) {
this->DTS = DTS;
this->KeyFrame = KeyFrame;
this->SampleStart = SampleStart;
this->FilePos = 0;
this->FrameSize = 0;
}
TFrameInfo::TFrameInfo(int64_t DTS, int64_t SampleStart, int64_t FilePos, unsigned int FrameSize, bool KeyFrame) {
this->DTS = DTS;
this->KeyFrame = KeyFrame;
this->SampleStart = SampleStart;
this->FilePos = FilePos;
this->FrameSize = FrameSize;
}
int FFTrack::WriteTimecodes(const char *TimecodeFile, char *ErrorMsg, unsigned MsgSize) {
std::ofstream Timecodes(TimecodeFile, std::ios::out | std::ios::trunc);
if (!Timecodes.is_open()) {
_snprintf(ErrorMsg, MsgSize, "Failed to open '%s' for writing", TimecodeFile);
return 1;
}
Timecodes << "# timecode format v2\n";
for (iterator Cur=begin(); Cur!=end(); Cur++)
Timecodes << std::fixed << ((Cur->DTS * TB.Num) / (double)TB.Den) << "\n";
return 0;
}
int FFTrack::FrameFromDTS(int64_t DTS) {
for (int i = 0; i < static_cast<int>(size()); i++)
if (at(i).DTS == DTS)
return i;
return -1;
}
int FFTrack::ClosestFrameFromDTS(int64_t DTS) {
int Frame = 0;
int64_t BestDiff = 0xFFFFFFFFFFFFFFLL; // big number
for (int i = 0; i < static_cast<int>(size()); i++) {
int64_t CurrentDiff = FFABS(at(i).DTS - DTS);
if (CurrentDiff < BestDiff) {
BestDiff = CurrentDiff;
Frame = i;
}
}
return Frame;
}
int FFTrack::FindClosestVideoKeyFrame(int Frame) {
Frame = FFMIN(FFMAX(Frame, 0), static_cast<int>(size()) - 1);
for (int i = Frame; i > 0; i--)
if (at(i).KeyFrame)
return i;
return 0;
}
int FFTrack::FindClosestAudioKeyFrame(int64_t Sample) {
for (size_t i = 0; i < size(); i++) {
if (at(i).SampleStart == Sample && at(i).KeyFrame)
return i;
else if (at(i).SampleStart > Sample && at(i).KeyFrame)
return i - 1;
}
return size() - 1;
}
FFTrack::FFTrack() {
this->TT = FFMS_TYPE_UNKNOWN;
this->TB.Num = 0;
this->TB.Den = 0;
}
FFTrack::FFTrack(int64_t Num, int64_t Den, FFMS_TrackType TT) {
this->TT = TT;
this->TB.Num = Num;
this->TB.Den = Den;
}
int FFIndex::WriteIndex(const char *IndexFile, char *ErrorMsg, unsigned MsgSize) {
std::ofstream IndexStream(IndexFile, std::ios::out | std::ios::binary | std::ios::trunc);
if (!IndexStream.is_open()) {
_snprintf(ErrorMsg, MsgSize, "Failed to open '%s' for writing", IndexFile);
return 1;
}
// Write the index file header
IndexHeader IH;
IH.Id = INDEXID;
IH.Version = INDEXVERSION;
IH.Tracks = size();
IH.Decoder = Decoder;
IH.LAVUVersion = LIBAVUTIL_VERSION_INT;
IH.LAVFVersion = LIBAVFORMAT_VERSION_INT;
IH.LAVCVersion = LIBAVCODEC_VERSION_INT;
IH.LSWSVersion = LIBSWSCALE_VERSION_INT;
IH.LPPVersion = LIBPOSTPROC_VERSION_INT;
IndexStream.write(reinterpret_cast<char *>(&IH), sizeof(IH));
for (unsigned int i = 0; i < IH.Tracks; i++) {
FFMS_TrackType TT = at(i).TT;
IndexStream.write(reinterpret_cast<char *>(&TT), sizeof(TT));
int64_t Num = at(i).TB.Num;
IndexStream.write(reinterpret_cast<char *>(&Num), sizeof(Num));
int64_t Den = at(i).TB.Den;
IndexStream.write(reinterpret_cast<char *>(&Den), sizeof(Den));
int64_t Frames = at(i).size();
IndexStream.write(reinterpret_cast<char *>(&Frames), sizeof(Frames));
for (FFTrack::iterator Cur=at(i).begin(); Cur!=at(i).end(); Cur++)
IndexStream.write(reinterpret_cast<char *>(&*Cur), sizeof(TFrameInfo));
}
return 0;
}
int FFIndex::ReadIndex(const char *IndexFile, char *ErrorMsg, unsigned MsgSize) {
std::ifstream Index(IndexFile, std::ios::in | std::ios::binary);
if (!Index.is_open()) {
_snprintf(ErrorMsg, MsgSize, "Failed to open '%s' for reading", IndexFile);
return 1;
}
// Read the index file header
IndexHeader IH;
Index.read(reinterpret_cast<char *>(&IH), sizeof(IH));
if (IH.Id != INDEXID) {
_snprintf(ErrorMsg, MsgSize, "'%s' is not a valid index file", IndexFile);
return 2;
}
if (IH.Version != INDEXVERSION) {
_snprintf(ErrorMsg, MsgSize, "'%s' is not the expected index version", IndexFile);
return 3;
}
if (IH.LAVUVersion != LIBAVUTIL_VERSION_INT || IH.LAVFVersion != LIBAVFORMAT_VERSION_INT ||
IH.LAVCVersion != LIBAVCODEC_VERSION_INT || IH.LSWSVersion != LIBSWSCALE_VERSION_INT ||
IH.LPPVersion != LIBPOSTPROC_VERSION_INT) {
_snprintf(ErrorMsg, MsgSize, "A different FFmpeg build was used to create '%s'", IndexFile);
return 4;
}
try {
Decoder = IH.Decoder;
for (unsigned int i = 0; i < IH.Tracks; i++) {
// Read how many records belong to the current stream
FFMS_TrackType TT;
Index.read(reinterpret_cast<char *>(&TT), sizeof(TT));
int64_t Num;
Index.read(reinterpret_cast<char *>(&Num), sizeof(Num));
int64_t Den;
Index.read(reinterpret_cast<char *>(&Den), sizeof(Den));
int64_t Frames;
Index.read(reinterpret_cast<char *>(&Frames), sizeof(Frames));
push_back(FFTrack(Num, Den, TT));
TFrameInfo FI(0, false);
for (size_t j = 0; j < Frames; j++) {
Index.read(reinterpret_cast<char *>(&FI), sizeof(TFrameInfo));
at(i).push_back(FI);
}
}
} catch (...) {
_snprintf(ErrorMsg, MsgSize, "Unknown error while reading index information in '%s'", IndexFile);
return 5;
}
return 0;
}
int GetCPUFlags() {
// FIXME Add proper feature detection when msvc isn't used
int Flags = PP_CPU_CAPS_MMX | PP_CPU_CAPS_MMX2;
#ifdef _MSC_VER
Flags = 0;
int CPUInfo[4];
__cpuid(CPUInfo, 0);
// PP and SWS defines have the same values for their defines so this actually works
if (CPUInfo[3] & (1 << 23))
Flags |= PP_CPU_CAPS_MMX;
if (CPUInfo[3] & (1 << 25))
Flags |= PP_CPU_CAPS_MMX2;
#endif
return Flags;
}
FFMS_TrackType HaaliTrackTypeToFFTrackType(int TT) {
switch (TT) {
case TT_VIDEO: return FFMS_TYPE_VIDEO; break;
case TT_AUDIO: return FFMS_TYPE_AUDIO; break;
case TT_SUB: return FFMS_TYPE_SUBTITLE; break;
default: return FFMS_TYPE_UNKNOWN;
}
}
int ReadFrame(uint64_t FilePos, unsigned int &FrameSize, CompressedStream *CS, MatroskaReaderContext &Context, char *ErrorMsg, unsigned MsgSize) {
if (CS) {
char CSBuffer[4096];
unsigned int DecompressedFrameSize = 0;
cs_NextFrame(CS, FilePos, FrameSize);
for (;;) {
int ReadBytes = cs_ReadData(CS, CSBuffer, sizeof(CSBuffer));
if (ReadBytes < 0) {
_snprintf(ErrorMsg, MsgSize, "Error decompressing data: %s", cs_GetLastError(CS));
return 1;
}
if (ReadBytes == 0) {
FrameSize = DecompressedFrameSize;
return 0;
}
if (Context.BufferSize < DecompressedFrameSize + ReadBytes) {
Context.BufferSize = FrameSize;
Context.Buffer = (uint8_t *)realloc(Context.Buffer, Context.BufferSize + 16);
if (Context.Buffer == NULL) {
_snprintf(ErrorMsg, MsgSize, "Out of memory");
return 2;
}
}
memcpy(Context.Buffer + DecompressedFrameSize, CSBuffer, ReadBytes);
DecompressedFrameSize += ReadBytes;
}
} else {
if (_fseeki64(Context.ST.fp, FilePos, SEEK_SET)) {
_snprintf(ErrorMsg, MsgSize, "fseek(): %s", strerror(errno));
return 3;
}
if (Context.BufferSize < FrameSize) {
Context.BufferSize = FrameSize;
Context.Buffer = (uint8_t *)realloc(Context.Buffer, Context.BufferSize + 16);
if (Context.Buffer == NULL) {
_snprintf(ErrorMsg, MsgSize, "Out of memory");
return 4;
}
}
size_t ReadBytes = fread(Context.Buffer, 1, FrameSize, Context.ST.fp);
if (ReadBytes != FrameSize) {
if (ReadBytes == 0) {
if (feof(Context.ST.fp)) {
_snprintf(ErrorMsg, MsgSize, "Unexpected EOF while reading frame");
return 5;
} else {
_snprintf(ErrorMsg, MsgSize, "Error reading frame: %s", strerror(errno));
return 6;
}
} else {
_snprintf(ErrorMsg, MsgSize, "Short read while reading frame");
return 7;
}
_snprintf(ErrorMsg, MsgSize, "Unknown read error");
return 8;
}
return 0;
}
}
bool AudioFMTIsFloat(SampleFormat FMT){
switch (FMT) {
case SAMPLE_FMT_FLT:
case SAMPLE_FMT_DBL:
return true;
default:
return false;
}
}
void InitNullPacket(AVPacket *pkt) {
av_init_packet(pkt);
pkt->data = NULL;
pkt->size = 0;
}
void FillAP(TAudioProperties &AP, AVCodecContext *CTX, FFTrack &Frames) {
AP.BitsPerSample = av_get_bits_per_sample_format(CTX->sample_fmt);
AP.Channels = CTX->channels;;
AP.Float = AudioFMTIsFloat(CTX->sample_fmt);
AP.SampleRate = CTX->sample_rate;
AP.NumSamples = (Frames.back()).SampleStart;
AP.FirstTime = ((Frames.front().DTS * Frames.TB.Num) / (double)Frames.TB.Den) / 1000;
AP.LastTime = ((Frames.back().DTS * Frames.TB.Num) / (double)Frames.TB.Den) / 1000;
}
#ifdef HAALISOURCE
unsigned vtSize(VARIANT &vt) {
if (V_VT(&vt) != (VT_ARRAY | VT_UI1))
return 0;
long lb,ub;
if (FAILED(SafeArrayGetLBound(V_ARRAY(&vt),1,&lb)) ||
FAILED(SafeArrayGetUBound(V_ARRAY(&vt),1,&ub)))
return 0;
return ub - lb + 1;
}
void vtCopy(VARIANT& vt,void *dest) {
unsigned sz = vtSize(vt);
if (sz > 0) {
void *vp;
if (SUCCEEDED(SafeArrayAccessData(V_ARRAY(&vt),&vp))) {
memcpy(dest,vp,sz);
SafeArrayUnaccessData(V_ARRAY(&vt));
}
}
}
#else
// used for matroska<->ffmpeg codec ID mapping to avoid Win32 dependency
typedef struct BITMAPINFOHEADER {
uint32_t biSize;
int32_t biWidth;
int32_t biHeight;
uint16_t biPlanes;
uint16_t biBitCount;
uint32_t biCompression;
uint32_t biSizeImage;
int32_t biXPelsPerMeter;
int32_t biYPelsPerMeter;
uint32_t biClrUsed;
uint32_t biClrImportant;
} BITMAPINFOHEADER;
#define MAKEFOURCC(ch0, ch1, ch2, ch3)\
((uint32_t)(uint8_t)(ch0) | ((uint32_t)(uint8_t)(ch1) << 8) |\
((uint32_t)(uint8_t)(ch2) << 16) | ((uint32_t)(uint8_t)(ch3) << 24 ))
#endif
CodecID MatroskaToFFCodecID(char *Codec, void *CodecPrivate) {
/* Look up native codecs */
for(int i = 0; ff_mkv_codec_tags[i].id != CODEC_ID_NONE; i++){
if(!strncmp(ff_mkv_codec_tags[i].str, Codec,
strlen(ff_mkv_codec_tags[i].str))){
return ff_mkv_codec_tags[i].id;
}
}
/* Video codecs for "avi in mkv" mode */
const AVCodecTag *const tags[] = { codec_bmp_tags, 0 };
if (!strcmp(Codec, "V_MS/VFW/FOURCC"))
return av_codec_get_id(tags, ((BITMAPINFOHEADER *)CodecPrivate)->biCompression);
// FIXME
/* Audio codecs for "avi in mkv" mode */
//#include "Mmreg.h"
//((WAVEFORMATEX *)TI->CodecPrivate)->wFormatTag
/* Fixup for uncompressed video formats */
/* Fixup for uncompressed audio formats */
return CODEC_ID_NONE;
}