Remove long-unmaintained SNES-specific dump format
This commit is contained in:
Ilari Liusvaara
parent
2995be7f12
commit
b9fedf0dde
2 changed files with 0 additions and 1157 deletions
|
|
@ -1,922 +0,0 @@
|
|||
#include <cstdint>
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
#include <sstream>
|
||||
#include <stdexcept>
|
||||
#include <cstring>
|
||||
|
||||
#define FLAG_WIDTH 1
|
||||
#define FLAG_HEIGHT 2
|
||||
#define FLAG_FRAMERATE 4
|
||||
#define FLAG_FULLRANGE 8
|
||||
#define FLAG_ITU601 0
|
||||
#define FLAG_ITU709 16
|
||||
#define FLAG_SMPTE240M 32
|
||||
#define FLAG_CS_MASK 48
|
||||
#define FLAG_8BIT 64
|
||||
#define FLAG_FAKENLARGE 128
|
||||
#define FLAG_DEDUP 256
|
||||
#define FLAG_OFFSET2 512
|
||||
#define FLAG_10FRAMES 1024
|
||||
#define FLAG_AR_CORRECT 2048
|
||||
|
||||
#define CMD_HIRES 1
|
||||
#define CMD_INTERLACED 2
|
||||
#define CMD_OVERSCAN 4
|
||||
#define CMD_PAL 8
|
||||
|
||||
#define MAX_DEDUP 9
|
||||
|
||||
//This buffer needs to be big enough to store 640x480 16-bit YCbCr 4:4:4 (6 bytes per pixel) image.
|
||||
#define MAXYUVSIZE (640 * 480 * 6)
|
||||
unsigned char yuv_buffer[MAXYUVSIZE];
|
||||
unsigned char old_yuv_buffer[MAXYUVSIZE];
|
||||
|
||||
//30 bit values.
|
||||
uint32_t ymatrix[0x80000];
|
||||
uint32_t cbmatrix[0x80000];
|
||||
uint32_t crmatrix[0x80000];
|
||||
|
||||
|
||||
#define TOYUV(src, idx) do {\
|
||||
uint32_t c = (static_cast<uint32_t>(src[(idx) + 0]) << 24) |\
|
||||
(static_cast<uint32_t>(src[(idx) + 1]) << 16) |\
|
||||
(static_cast<uint32_t>(src[(idx) + 2]) << 8) |\
|
||||
static_cast<uint32_t>(src[(idx) + 3]);\
|
||||
Y += ymatrix[c & 0x7FFFF];\
|
||||
Cb += cbmatrix[c & 0x7FFFF];\
|
||||
Cr += crmatrix[c & 0x7FFFF];\
|
||||
} while(0)
|
||||
|
||||
#define RGB2YUV_SHIFT 14
|
||||
|
||||
class sox_output
|
||||
{
|
||||
public:
|
||||
sox_output(std::ostream& soxs, uint32_t apurate, bool silence2);
|
||||
void close();
|
||||
void add_sample(unsigned char* buf);
|
||||
uint64_t get_samples();
|
||||
private:
|
||||
std::ostream& strm;
|
||||
uint64_t samples;
|
||||
};
|
||||
|
||||
class sdmp_input_stream
|
||||
{
|
||||
public:
|
||||
sdmp_input_stream(std::istream& sdmp);
|
||||
uint32_t get_cpurate();
|
||||
uint32_t get_apurate();
|
||||
int read_command();
|
||||
void read_linepair(unsigned char* buffer);
|
||||
void copy_audio_sample(sox_output& audio_out);
|
||||
private:
|
||||
std::istream& strm;
|
||||
uint32_t cpurate;
|
||||
uint32_t apurate;
|
||||
};
|
||||
|
||||
class time_tracker
|
||||
{
|
||||
public:
|
||||
time_tracker(uint32_t _cpurate);
|
||||
void add_2s();
|
||||
void advance(bool pal, bool interlaced);
|
||||
uint64_t get_ts();
|
||||
private:
|
||||
uint32_t cpurate;
|
||||
uint64_t w;
|
||||
uint64_t n;
|
||||
};
|
||||
|
||||
class dup_tracker
|
||||
{
|
||||
public:
|
||||
dup_tracker(std::ostream& _tcfile, uint32_t _flags);
|
||||
uint32_t process(unsigned char* buffer, size_t bufsize, int pkt_type, time_tracker& ts);
|
||||
private:
|
||||
std::ostream& tcfile;
|
||||
uint32_t flags;
|
||||
uint32_t counter;
|
||||
};
|
||||
|
||||
|
||||
struct store16
|
||||
{
|
||||
static const size_t esize = 2;
|
||||
static void store(unsigned char* buffer, size_t idx, size_t psep, uint32_t v1, uint32_t v2,
|
||||
uint32_t v3)
|
||||
{
|
||||
*reinterpret_cast<uint16_t*>(buffer + idx) = (v1 >> RGB2YUV_SHIFT);
|
||||
*reinterpret_cast<uint16_t*>(buffer + idx + psep) = (v2 >> RGB2YUV_SHIFT);
|
||||
*reinterpret_cast<uint16_t*>(buffer + idx + 2 * psep) = (v3 >> RGB2YUV_SHIFT);
|
||||
}
|
||||
};
|
||||
|
||||
struct store8
|
||||
{
|
||||
static const size_t esize = 1;
|
||||
static void store(unsigned char* buffer, size_t idx, size_t psep, uint32_t v1, uint32_t v2,
|
||||
uint32_t v3)
|
||||
{
|
||||
buffer[idx] = (v1 >> (RGB2YUV_SHIFT + 8));
|
||||
buffer[idx + psep] = (v2 >> (RGB2YUV_SHIFT + 8));
|
||||
buffer[idx + 2 * psep] = (v3 >> (RGB2YUV_SHIFT + 8));
|
||||
}
|
||||
};
|
||||
|
||||
template<class store, size_t ioff1, size_t ioff2, size_t ioff3, size_t ooff1, size_t ooff2, size_t ooff3>
|
||||
struct loadstore
|
||||
{
|
||||
static const size_t esize = store::esize;
|
||||
static void convert(unsigned char* obuffer, size_t oidx, const unsigned char* ibuffer, size_t iidx,
|
||||
size_t psep)
|
||||
{
|
||||
//Compiler should be able to eliminate every if out of this.
|
||||
uint32_t Y = 0;
|
||||
uint32_t Cb = 0;
|
||||
uint32_t Cr = 0;
|
||||
TOYUV(ibuffer, iidx);
|
||||
if(ioff1 > 0)
|
||||
TOYUV(ibuffer, iidx + ioff1 * 4);
|
||||
if(ioff2 > 0)
|
||||
TOYUV(ibuffer, iidx + ioff2 * 4);
|
||||
if(ioff3 > 0)
|
||||
TOYUV(ibuffer, iidx + ioff3 * 4);
|
||||
if(ioff1 > 0 && ioff2 > 0 && ioff3 > 0) {
|
||||
Y >>= 2;
|
||||
Cb >>= 2;
|
||||
Cr >>= 2;
|
||||
} else if(ioff1 > 0) {
|
||||
Y >>= 1;
|
||||
Cb >>= 1;
|
||||
Cr >>= 1;
|
||||
}
|
||||
store::store(obuffer, oidx, psep, Y, Cb, Cr);
|
||||
if(ooff1 > 0)
|
||||
store::store(obuffer, oidx + ooff1 * store::esize, psep, Y, Cb, Cr);
|
||||
if(ooff2 > 0)
|
||||
store::store(obuffer, oidx + ooff2 * store::esize, psep, Y, Cb, Cr);
|
||||
if(ooff3 > 0)
|
||||
store::store(obuffer, oidx + ooff3 * store::esize, psep, Y, Cb, Cr);
|
||||
}
|
||||
};
|
||||
|
||||
template<class proc, size_t lim, size_t igap, size_t ogap>
|
||||
struct loop
|
||||
{
|
||||
static void f(unsigned char* buffer, const unsigned char* src, size_t psep)
|
||||
{
|
||||
for(size_t i = 0; i < lim; i++)
|
||||
proc::convert(buffer, proc::esize * ogap * i, src, 4 * igap * i, psep);
|
||||
}
|
||||
};
|
||||
|
||||
//Render a line pair of YUV with 256x224/240
|
||||
template<class store>
|
||||
void render_yuv_256_240(unsigned char* buffer, const unsigned char* src, size_t psep, bool hires, bool interlaced)
|
||||
{
|
||||
if(hires)
|
||||
if(interlaced)
|
||||
loop<loadstore<store, 1, 512, 513, 0, 0, 0>, 256, 2, 1>::f(buffer, src, psep);
|
||||
else
|
||||
loop<loadstore<store, 1, 0, 0, 0, 0, 0>, 256, 2, 1>::f(buffer, src, psep);
|
||||
else
|
||||
if(interlaced)
|
||||
loop<loadstore<store, 512, 0, 0, 0, 0, 0>, 256, 1, 1>::f(buffer, src, psep);
|
||||
else
|
||||
loop<loadstore<store, 0, 0, 0, 0, 0, 0>, 256, 1, 1>::f(buffer, src, psep);
|
||||
}
|
||||
|
||||
//Render a line pair of YUV with 512x224/240
|
||||
template<class store>
|
||||
void render_yuv_512_240(unsigned char* buffer, const unsigned char* src, size_t psep, bool hires, bool interlaced)
|
||||
{
|
||||
if(hires)
|
||||
if(interlaced)
|
||||
loop<loadstore<store, 512, 0, 0, 0, 0, 0>, 512, 1, 1>::f(buffer, src, psep);
|
||||
else
|
||||
loop<loadstore<store, 0, 0, 0, 0, 0, 0>, 512, 1, 1>::f(buffer, src, psep);
|
||||
else
|
||||
if(interlaced)
|
||||
loop<loadstore<store, 512, 0, 0, 1, 0, 0>, 256, 1, 2>::f(buffer, src, psep);
|
||||
else
|
||||
loop<loadstore<store, 0, 0, 0, 1, 0, 0>, 256, 1, 2>::f(buffer, src, psep);
|
||||
}
|
||||
|
||||
//Render a line pair of YUV with 256x448/480
|
||||
template<class store>
|
||||
void render_yuv_256_480(unsigned char* buffer, const unsigned char* src, size_t psep, bool hires, bool interlaced)
|
||||
{
|
||||
if(hires)
|
||||
if(interlaced) {
|
||||
loop<loadstore<store, 1, 0, 0, 0, 0, 0>, 256, 2, 1>::f(buffer, src, psep);
|
||||
loop<loadstore<store, 1, 0, 0, 0, 0, 0>, 256, 2, 1>::f(buffer + 256 * store::esize,
|
||||
src + 2048, psep);
|
||||
} else
|
||||
loop<loadstore<store, 1, 0, 0, 256, 0, 0>, 256, 2, 1>::f(buffer, src, psep);
|
||||
else
|
||||
if(interlaced) {
|
||||
loop<loadstore<store, 0, 0, 0, 0, 0, 0>, 256, 1, 1>::f(buffer, src, psep);
|
||||
loop<loadstore<store, 0, 0, 0, 0, 0, 0>, 256, 1, 1>::f(buffer + 256 * store::esize,
|
||||
src + 2048, psep);
|
||||
} else
|
||||
loop<loadstore<store, 0, 0, 0, 256, 0, 0>, 256, 1, 1>::f(buffer, src, psep);
|
||||
}
|
||||
|
||||
//Render a line pair of YUV with 512x448/480
|
||||
template<class store>
|
||||
void render_yuv_512_480(unsigned char* buffer, const unsigned char* src, size_t psep, bool hires, bool interlaced)
|
||||
{
|
||||
if(hires)
|
||||
if(interlaced) {
|
||||
loop<loadstore<store, 0, 0, 0, 0, 0, 0>, 512, 1, 1>::f(buffer, src, psep);
|
||||
loop<loadstore<store, 0, 0, 0, 0, 0, 0>, 512, 1, 1>::f(buffer + 512 * store::esize,
|
||||
src + 2048, psep);
|
||||
} else
|
||||
loop<loadstore<store, 0, 0, 0, 512, 0, 0>, 512, 1, 1>::f(buffer, src, psep);
|
||||
else
|
||||
if(interlaced) {
|
||||
loop<loadstore<store, 0, 0, 0, 1, 0, 0>, 256, 1, 2>::f(buffer, src, psep);
|
||||
loop<loadstore<store, 0, 0, 0, 1, 0, 0>, 256, 1, 2>::f(buffer + 512 * store::esize,
|
||||
src + 2048, psep);
|
||||
} else
|
||||
loop<loadstore<store, 0, 0, 0, 1, 512, 513>, 256, 1, 2>::f(buffer, src, psep);
|
||||
}
|
||||
|
||||
//Render a line pair of YUV with 512x448/480 fakeexpand
|
||||
template<class store>
|
||||
void render_yuv_fe(unsigned char* buffer, const unsigned char* src, size_t psep, bool hires, bool interlaced)
|
||||
{
|
||||
if(hires)
|
||||
if(interlaced) {
|
||||
loop<loadstore<store, 0, 0, 0, 0, 0, 0>, 512, 1, 1>::f(buffer, src, psep);
|
||||
loop<loadstore<store, 0, 0, 0, 0, 0, 0>, 512, 1, 1>::f(buffer + 512 * store::esize,
|
||||
src + 2048, psep);
|
||||
} else
|
||||
loop<loadstore<store, 1, 0, 0, 1, 512, 513>, 256, 2, 2>::f(buffer, src, psep);
|
||||
else
|
||||
if(interlaced) {
|
||||
loop<loadstore<store, 0, 0, 0, 1, 0, 0>, 256, 1, 2>::f(buffer, src, psep);
|
||||
loop<loadstore<store, 0, 0, 0, 1, 0, 0>, 256, 1, 2>::f(buffer + 512 * store::esize,
|
||||
src + 2048, psep);
|
||||
} else
|
||||
loop<loadstore<store, 0, 0, 0, 1, 256, 257>, 256, 1, 2>::f(buffer, src, psep);
|
||||
}
|
||||
|
||||
typedef void (*render_yuv_t)(unsigned char* buffer, const unsigned char* src, size_t psep, bool hires,
|
||||
bool interlaced);
|
||||
|
||||
render_yuv_t get_renderer_for(int32_t flags)
|
||||
{
|
||||
int32_t mode = flags & (FLAG_WIDTH | FLAG_HEIGHT | FLAG_8BIT | FLAG_FAKENLARGE);
|
||||
if(mode == 0)
|
||||
return render_yuv_256_240<store16>;
|
||||
if(mode == FLAG_WIDTH)
|
||||
return render_yuv_512_240<store16>;
|
||||
if(mode == FLAG_HEIGHT)
|
||||
return render_yuv_256_480<store16>;
|
||||
if(mode == (FLAG_WIDTH | FLAG_HEIGHT))
|
||||
return render_yuv_512_480<store16>;
|
||||
if(mode == (FLAG_WIDTH | FLAG_HEIGHT | FLAG_FAKENLARGE))
|
||||
return render_yuv_fe<store16>;
|
||||
if(mode == FLAG_8BIT)
|
||||
return render_yuv_256_240<store8>;
|
||||
if(mode == (FLAG_WIDTH | FLAG_8BIT))
|
||||
return render_yuv_512_240<store8>;
|
||||
if(mode == (FLAG_HEIGHT | FLAG_8BIT))
|
||||
return render_yuv_256_480<store8>;
|
||||
if(mode == (FLAG_WIDTH | FLAG_HEIGHT | FLAG_8BIT))
|
||||
return render_yuv_512_480<store8>;
|
||||
if(mode == (FLAG_WIDTH | FLAG_HEIGHT | FLAG_FAKENLARGE | FLAG_8BIT))
|
||||
return render_yuv_fe<store8>;
|
||||
throw std::runtime_error("get_renderer_for: Unknown flags combination");
|
||||
}
|
||||
|
||||
void init_matrix(double Kb, double Kr, bool fullrange)
|
||||
{
|
||||
double RY = Kr;
|
||||
double GY = 1 - Kr - Kb;
|
||||
double BY = Kb;
|
||||
double RPb = -0.5 * Kr / (1 - Kb);
|
||||
double GPb = -0.5 * (1 - Kr - Kb) / (1 - Kb);
|
||||
double BPb = 0.5;
|
||||
double RPr = 0.5;
|
||||
double GPr = -0.5 * (1 - Kr - Kb) / (1 - Kr);
|
||||
double BPr = -0.5 * Kb / (1 - Kr);
|
||||
for(uint32_t i = 0; i < 0x80000; i++) {
|
||||
uint32_t l = 1 + ((i >> 15) & 0xF);
|
||||
//Range of (r,g,b) is 0...496.
|
||||
uint32_t r = (l * ((i >> 0) & 0x1F));
|
||||
uint32_t g = (l * ((i >> 5) & 0x1F));
|
||||
uint32_t b = (l * ((i >> 10) & 0x1F));
|
||||
double Y = (RY * r + GY * g + BY * b) / 496 * (fullrange ? 255 : 219) + (fullrange ? 0 : 16);
|
||||
double Cb = (RPb * r + GPb * g + BPb * b) / 496 * (fullrange ? 255 : 224) + 128;
|
||||
double Cr = (RPr * r + GPr * g + BPr * b) / 496 * (fullrange ? 255 : 224) + 128;
|
||||
ymatrix[i] = static_cast<uint32_t>(Y * 4194304 + 0.5);
|
||||
cbmatrix[i] = static_cast<uint32_t>(Cb * 4194304 + 0.5);
|
||||
crmatrix[i] = static_cast<uint32_t>(Cr * 4194304 + 0.5);
|
||||
}
|
||||
}
|
||||
|
||||
//Load RGB to YUV conversion matrix.
|
||||
void load_rgb2yuv_matrix(uint32_t flags)
|
||||
{
|
||||
switch(flags & (FLAG_CS_MASK))
|
||||
{
|
||||
case FLAG_ITU601:
|
||||
init_matrix(0.114, 0.229, flags & FLAG_FULLRANGE);
|
||||
break;
|
||||
case FLAG_ITU709:
|
||||
init_matrix(0.0722, 0.2126, flags & FLAG_FULLRANGE);
|
||||
break;
|
||||
case FLAG_SMPTE240M:
|
||||
init_matrix(0.087, 0.212, flags & FLAG_FULLRANGE);
|
||||
break;
|
||||
default:
|
||||
init_matrix(0.114, 0.229, flags & FLAG_FULLRANGE);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
uint64_t double_to_ieeefp(double v)
|
||||
{
|
||||
unsigned mag = 1023;
|
||||
while(v >= 2) {
|
||||
mag++;
|
||||
v /= 2;
|
||||
}
|
||||
while(v < 1) {
|
||||
mag--;
|
||||
v *= 2;
|
||||
}
|
||||
uint64_t v2 = mag;
|
||||
v -= 1;
|
||||
for(unsigned i = 0; i < 52; i++) {
|
||||
v *= 2;
|
||||
v2 = 2 * v2 + ((v >= 1) ? 1 : 0);
|
||||
if(v >= 1)
|
||||
v -= 1;
|
||||
}
|
||||
return v2;
|
||||
}
|
||||
|
||||
|
||||
sox_output::sox_output(std::ostream& soxs, uint32_t apurate, bool silence2)
|
||||
: strm(soxs)
|
||||
{
|
||||
uint64_t sndrateR = double_to_ieeefp(static_cast<double>(apurate) / 768.0);
|
||||
unsigned char sox_header[32] = {0};
|
||||
sox_header[0] = 0x2E; //Magic
|
||||
sox_header[1] = 0x53; //Magic
|
||||
sox_header[2] = 0x6F; //Magic
|
||||
sox_header[3] = 0x58; //Magic
|
||||
sox_header[4] = 0x1C; //Magic
|
||||
sox_header[16] = sndrateR;
|
||||
sox_header[17] = sndrateR >> 8;
|
||||
sox_header[18] = sndrateR >> 16;
|
||||
sox_header[19] = sndrateR >> 24;
|
||||
sox_header[20] = sndrateR >> 32;
|
||||
sox_header[21] = sndrateR >> 40;
|
||||
sox_header[22] = sndrateR >> 48;
|
||||
sox_header[23] = sndrateR >> 56;
|
||||
sox_header[24] = 2;
|
||||
strm.write(reinterpret_cast<char*>(sox_header), 32);
|
||||
if(!strm)
|
||||
throw std::runtime_error("Can't write audio header");
|
||||
samples = 0;
|
||||
if(silence2) {
|
||||
uint64_t nullsamples = apurate / 384;
|
||||
samples = nullsamples;
|
||||
const size_t bufsz = 512;
|
||||
char nbuffer[8 * bufsz] = {0};
|
||||
while(nullsamples > bufsz) {
|
||||
strm.write(nbuffer, 8 * bufsz);
|
||||
nullsamples -= bufsz;
|
||||
}
|
||||
strm.write(nbuffer, 8 * nullsamples);
|
||||
if(!strm)
|
||||
throw std::runtime_error("Can't write 2 second silence");
|
||||
}
|
||||
}
|
||||
|
||||
void sox_output::close()
|
||||
{
|
||||
//Sox internally multiplies sample count by channel count.
|
||||
unsigned char sox_header[8];
|
||||
sox_header[0] = samples << 1;
|
||||
sox_header[1] = samples >> 7;
|
||||
sox_header[2] = samples >> 15;
|
||||
sox_header[3] = samples >> 23;
|
||||
sox_header[4] = samples >> 31;
|
||||
sox_header[5] = samples >> 39;
|
||||
sox_header[6] = samples >> 47;
|
||||
sox_header[7] = samples >> 55;
|
||||
strm.seekp(8, std::ios::beg);
|
||||
if(!strm)
|
||||
throw std::runtime_error("Can't seek to fix .sox header");
|
||||
strm.write(reinterpret_cast<char*>(sox_header), 8);
|
||||
if(!strm)
|
||||
throw std::runtime_error("Can't fix audio header");
|
||||
}
|
||||
|
||||
void sox_output::add_sample(unsigned char* buf)
|
||||
{
|
||||
strm.write(reinterpret_cast<char*>(buf), 8);
|
||||
if(!strm)
|
||||
throw std::runtime_error("Can't write audio sample");
|
||||
samples++;
|
||||
}
|
||||
|
||||
uint64_t sox_output::get_samples()
|
||||
{
|
||||
return samples;
|
||||
}
|
||||
|
||||
sdmp_input_stream::sdmp_input_stream(std::istream& sdmp)
|
||||
: strm(sdmp)
|
||||
{
|
||||
unsigned char header[12];
|
||||
strm.read(reinterpret_cast<char*>(header), 12);
|
||||
if(!strm)
|
||||
throw std::runtime_error("Can't read sdump header");
|
||||
if(header[0] != 'S' || header[1] != 'D' || header[2] != 'M' || header[3] != 'P')
|
||||
throw std::runtime_error("Bad sdump magic");
|
||||
cpurate = (static_cast<uint32_t>(header[4]) << 24) |
|
||||
(static_cast<uint32_t>(header[5]) << 16) |
|
||||
(static_cast<uint32_t>(header[6]) << 8) |
|
||||
static_cast<uint32_t>(header[7]);
|
||||
apurate = (static_cast<uint32_t>(header[8]) << 24) |
|
||||
(static_cast<uint32_t>(header[9]) << 16) |
|
||||
(static_cast<uint32_t>(header[10]) << 8) |
|
||||
static_cast<uint32_t>(header[11]);
|
||||
}
|
||||
|
||||
uint32_t sdmp_input_stream::get_cpurate()
|
||||
{
|
||||
return cpurate;
|
||||
}
|
||||
|
||||
uint32_t sdmp_input_stream::get_apurate()
|
||||
{
|
||||
return apurate;
|
||||
}
|
||||
|
||||
int sdmp_input_stream::read_command()
|
||||
{
|
||||
unsigned char cmd;
|
||||
strm >> cmd;
|
||||
if(!strm)
|
||||
return -1;
|
||||
return cmd;
|
||||
}
|
||||
|
||||
void sdmp_input_stream::read_linepair(unsigned char* buffer)
|
||||
{
|
||||
strm.read(reinterpret_cast<char*>(buffer), 4096);
|
||||
if(!strm)
|
||||
throw std::runtime_error("Can't read picture payload");
|
||||
}
|
||||
|
||||
void sdmp_input_stream::copy_audio_sample(sox_output& audio_out)
|
||||
{
|
||||
unsigned char ibuf[4];
|
||||
unsigned char obuf[8];
|
||||
strm.read(reinterpret_cast<char*>(ibuf), 4);
|
||||
if(!strm)
|
||||
throw std::runtime_error("Can't read sound packet payload");
|
||||
obuf[0] = 0;
|
||||
obuf[1] = 0;
|
||||
obuf[2] = ibuf[1];
|
||||
obuf[3] = ibuf[0];
|
||||
obuf[4] = 0;
|
||||
obuf[5] = 0;
|
||||
obuf[6] = ibuf[3];
|
||||
obuf[7] = ibuf[2];
|
||||
audio_out.add_sample(obuf);
|
||||
}
|
||||
|
||||
time_tracker::time_tracker(uint32_t _cpurate)
|
||||
{
|
||||
cpurate = _cpurate;
|
||||
w = n = 0;
|
||||
}
|
||||
|
||||
void time_tracker::add_2s()
|
||||
{
|
||||
w += 2000;
|
||||
}
|
||||
|
||||
void time_tracker::advance(bool pal, bool interlaced)
|
||||
{
|
||||
uint64_t tcc = pal ? 425568000 : (interlaced ? 357368000 : 357366000);
|
||||
w += tcc / cpurate;
|
||||
n += tcc % cpurate;
|
||||
w += n / cpurate;
|
||||
n %= cpurate;
|
||||
}
|
||||
|
||||
uint64_t time_tracker::get_ts()
|
||||
{
|
||||
return w;
|
||||
}
|
||||
|
||||
dup_tracker::dup_tracker(std::ostream& _tcfile, uint32_t _flags)
|
||||
: tcfile(_tcfile)
|
||||
{
|
||||
flags = _flags;
|
||||
counter = 0;
|
||||
}
|
||||
|
||||
uint32_t dup_tracker::process(unsigned char* buffer, size_t bufsize, int pkt_type, time_tracker& ts)
|
||||
{
|
||||
if(flags & FLAG_DEDUP) {
|
||||
if(memcmp(buffer, old_yuv_buffer, bufsize)) {
|
||||
memcpy(old_yuv_buffer, buffer, bufsize);
|
||||
counter = 0;
|
||||
} else
|
||||
counter = (counter + 1) % MAX_DEDUP;
|
||||
if(counter)
|
||||
return 0;
|
||||
else {
|
||||
tcfile << ts.get_ts() << std::endl;
|
||||
if(!tcfile)
|
||||
throw std::runtime_error("Can't write frame timestamp");
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
if(pkt_type & CMD_PAL)
|
||||
return 1; //No wrong framerate correction in PAL mode.
|
||||
bool framerate_flag = (flags & FLAG_FRAMERATE);
|
||||
bool interlaced = (pkt_type & CMD_INTERLACED);
|
||||
if(!framerate_flag && interlaced) {
|
||||
//This uses 357368 TU instead of 357366 TU.
|
||||
//-> Every 178683rd frame is duplicated.
|
||||
counter = (counter + 1) % 178683;
|
||||
if(counter)
|
||||
return 2;
|
||||
}
|
||||
if(framerate_flag && !interlaced) {
|
||||
//This uses 357366 TU instead of 357368 TU.
|
||||
//-> Every 178684th frame is dropped.
|
||||
counter = (counter + 1) % 178684;
|
||||
if(!counter)
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
size_t calculate_line_separation(int32_t flags, int pkt_type)
|
||||
{
|
||||
size_t s = 256;
|
||||
if(flags & FLAG_AR_CORRECT)
|
||||
if(pkt_type & CMD_PAL)
|
||||
s = (flags & FLAG_WIDTH) ? 640 : 320;
|
||||
else
|
||||
s = (flags & FLAG_WIDTH) ? 598 : 298;
|
||||
else if(flags & FLAG_WIDTH)
|
||||
s *= 2;
|
||||
if(flags & FLAG_HEIGHT)
|
||||
s *= 2;
|
||||
if(!(flags & FLAG_8BIT))
|
||||
s *= 2;
|
||||
return s;
|
||||
}
|
||||
|
||||
size_t calculate_plane_separation(int32_t flags, int pkt_type)
|
||||
{
|
||||
size_t s = calculate_line_separation(flags, pkt_type);
|
||||
if(pkt_type & CMD_PAL)
|
||||
s *= 240;
|
||||
else
|
||||
s *= 224;
|
||||
return s;
|
||||
}
|
||||
|
||||
bool is_renderable_line(int pkt_type, unsigned line_pair, unsigned rendered)
|
||||
{
|
||||
switch(pkt_type & (CMD_OVERSCAN | CMD_PAL)) {
|
||||
case 0:
|
||||
return (line_pair >= 9 && rendered < 224);
|
||||
case CMD_OVERSCAN:
|
||||
return (line_pair >= 16 && rendered < 224);
|
||||
case CMD_PAL:
|
||||
return (line_pair >= 1 && rendered < 239);
|
||||
case CMD_PAL | CMD_INTERLACED:
|
||||
return (line_pair >= 9 && rendered < 239);
|
||||
};
|
||||
return false;
|
||||
}
|
||||
|
||||
void lanczos_256_298_16(unsigned short* dst, unsigned short* src);
|
||||
void lanczos_256_320_16(unsigned short* dst, unsigned short* src);
|
||||
void lanczos_512_598_16(unsigned short* dst, unsigned short* src);
|
||||
void lanczos_512_640_16(unsigned short* dst, unsigned short* src);
|
||||
void lanczos_256_298_8(unsigned char* dst, unsigned char* src);
|
||||
void lanczos_256_320_8(unsigned char* dst, unsigned char* src);
|
||||
void lanczos_512_598_8(unsigned char* dst, unsigned char* src);
|
||||
void lanczos_512_640_8(unsigned char* dst, unsigned char* src);
|
||||
|
||||
void do_lanczos(unsigned char* dst, unsigned char* src, bool xhi, bool yhi, bool pal, bool lc, size_t psep)
|
||||
{
|
||||
unsigned char* dstN[3];
|
||||
unsigned short* dstW[3];
|
||||
unsigned char* srcN[3];
|
||||
unsigned short* srcW[3];
|
||||
dstN[0] = dst;
|
||||
dstN[1] = dst + psep;
|
||||
dstN[2] = dst + 2 * psep;
|
||||
dstW[0] = reinterpret_cast<unsigned short*>(dst);
|
||||
dstW[1] = reinterpret_cast<unsigned short*>(dst + psep);
|
||||
dstW[2] = reinterpret_cast<unsigned short*>(dst + 2 * psep);
|
||||
srcN[0] = src;
|
||||
srcN[1] = src + 2048;
|
||||
srcN[2] = src + 4096;
|
||||
srcW[0] = reinterpret_cast<unsigned short*>(src);
|
||||
srcW[1] = reinterpret_cast<unsigned short*>(src + 2048);
|
||||
srcW[2] = reinterpret_cast<unsigned short*>(src + 4096);
|
||||
unsigned doffset = pal ? (xhi ? 640 : 320) : (xhi ? 598 : 298);
|
||||
unsigned soffset = xhi ? 512 : 256;
|
||||
void (*fn8)(unsigned char* dst, unsigned char* src);
|
||||
void (*fn16)(unsigned short* dst, unsigned short* src);
|
||||
if(xhi && pal) {
|
||||
fn8 = lanczos_512_640_8;
|
||||
fn16 = lanczos_512_640_16;
|
||||
} else if(xhi && !pal) {
|
||||
fn8 = lanczos_512_598_8;
|
||||
fn16 = lanczos_512_598_16;
|
||||
} else if(!xhi && pal) {
|
||||
fn8 = lanczos_256_320_8;
|
||||
fn16 = lanczos_256_320_16;
|
||||
} else if(!xhi && !pal) {
|
||||
fn8 = lanczos_256_298_8;
|
||||
fn16 = lanczos_256_298_16;
|
||||
}
|
||||
if(lc) {
|
||||
for(unsigned i = 0; i < 3; i++)
|
||||
fn8(dstN[i], srcN[i]);
|
||||
if(yhi)
|
||||
for(unsigned i = 0; i < 3; i++)
|
||||
fn8(dstN[i] + doffset, srcN[i] + soffset);
|
||||
} else {
|
||||
for(unsigned i = 0; i < 3; i++)
|
||||
fn16(dstW[i], srcW[i]);
|
||||
if(yhi)
|
||||
for(unsigned i = 0; i < 3; i++)
|
||||
fn16(dstW[i] + doffset, srcW[i] + soffset);
|
||||
}
|
||||
}
|
||||
|
||||
void call_render_yuv(unsigned char* buffer, unsigned char* buf, size_t psep, int pkt_type, int32_t flags)
|
||||
{
|
||||
render_yuv_t render_yuv = get_renderer_for(flags);
|
||||
unsigned char tmp[6144];
|
||||
if(flags & FLAG_AR_CORRECT) {
|
||||
render_yuv(tmp, buf, 2048, pkt_type & CMD_HIRES, pkt_type & CMD_INTERLACED);
|
||||
bool xhi = (flags & FLAG_WIDTH);
|
||||
bool yhi = (flags & FLAG_HEIGHT);
|
||||
bool pal = (pkt_type & CMD_PAL);
|
||||
bool lc = (flags & FLAG_8BIT);
|
||||
do_lanczos(buffer, tmp, xhi, yhi, pal, lc, psep);
|
||||
} else
|
||||
render_yuv(buffer, buf, psep, pkt_type & CMD_HIRES, pkt_type & CMD_INTERLACED);
|
||||
}
|
||||
|
||||
size_t render_frame(sdmp_input_stream& in, int pkt_type, int32_t flags, unsigned char* buffer)
|
||||
{
|
||||
unsigned char buf[4096];
|
||||
unsigned physline = 0;
|
||||
size_t psep = calculate_plane_separation(flags, pkt_type);
|
||||
size_t lsep = calculate_line_separation(flags, pkt_type);
|
||||
for(unsigned i = 0; i < 256; i++) {
|
||||
in.read_linepair(buf);
|
||||
if(!is_renderable_line(pkt_type, i, physline))
|
||||
continue;
|
||||
call_render_yuv(buffer + physline * lsep, buf, psep, pkt_type, flags);
|
||||
physline++;
|
||||
}
|
||||
if(pkt_type & CMD_PAL) {
|
||||
//Render a black line to pad the image.
|
||||
memset(buf, 0, 4096);
|
||||
call_render_yuv(buffer + physline * lsep, buf, psep, pkt_type, flags);
|
||||
}
|
||||
return 3 * psep;
|
||||
}
|
||||
|
||||
void write_frame(std::ostream& yout, unsigned char* buffer, size_t bufsize, unsigned times_ctr, uint64_t& frames)
|
||||
{
|
||||
for(unsigned k = 0; k < times_ctr; k++)
|
||||
yout.write(reinterpret_cast<char*>(buffer), bufsize);
|
||||
if(!yout)
|
||||
throw std::runtime_error("Can't write frame");
|
||||
frames += times_ctr;
|
||||
}
|
||||
|
||||
void sdump2sox(std::istream& in, std::ostream& yout, std::ostream& sout, std::ostream& tout, int32_t flags)
|
||||
{
|
||||
sdmp_input_stream sdmp_in(in);
|
||||
sox_output sox_out(sout, sdmp_in.get_apurate(), flags & FLAG_OFFSET2);
|
||||
time_tracker ts(sdmp_in.get_cpurate());
|
||||
dup_tracker dupt(tout, flags);
|
||||
|
||||
load_rgb2yuv_matrix(flags);
|
||||
|
||||
if(flags & FLAG_OFFSET2)
|
||||
ts.add_2s();
|
||||
if(flags & FLAG_DEDUP) {
|
||||
tout << "# timecode format v2" << std::endl;
|
||||
if(flags & FLAG_10FRAMES)
|
||||
tout << "0\n200\n400\n600\n800\n1000\n1200\n1400\n1600\n1800" << std::endl;
|
||||
}
|
||||
|
||||
uint64_t frames = 0;
|
||||
bool is_pal = false;
|
||||
|
||||
while(true) {
|
||||
bool lf = false;
|
||||
int pkttype = sdmp_in.read_command();
|
||||
if(pkttype < 0)
|
||||
break; //End of stream.
|
||||
if((pkttype & 0xF0) == 0) {
|
||||
//Picture. Read the 1MiB of picture data one line pair at a time.
|
||||
size_t fsize = render_frame(sdmp_in, pkttype, flags, yuv_buffer);
|
||||
is_pal = is_pal || (pkttype & CMD_PAL);
|
||||
uint32_t times = dupt.process(yuv_buffer, fsize, pkttype, ts);
|
||||
write_frame(yout, yuv_buffer, fsize, times, frames);
|
||||
ts.advance(pkttype & CMD_PAL, pkttype & CMD_INTERLACED);
|
||||
lf = true;
|
||||
} else if(pkttype == 16) {
|
||||
sdmp_in.copy_audio_sample(sox_out);
|
||||
} else {
|
||||
std::ostringstream str;
|
||||
str << "Unknown command byte " << static_cast<unsigned>(pkttype);
|
||||
throw std::runtime_error(str.str());
|
||||
}
|
||||
if(lf && frames % 100 == 0) {
|
||||
std::cout << "\e[1G" << frames << " frames, " << sox_out.get_samples() << " samples."
|
||||
<< std::flush;
|
||||
}
|
||||
}
|
||||
sox_out.close();
|
||||
std::cout << "Sound sampling rate is " << static_cast<double>(sdmp_in.get_apurate()) / 768.0 << "Hz"
|
||||
<< std::endl;
|
||||
std::cout << "Wrote " << sox_out.get_samples() << " samples." << std::endl;
|
||||
std::cout << "Audio length is " << 768.0 * sox_out.get_samples() / sdmp_in.get_apurate() << "s." << std::endl;
|
||||
double vrate = 0;
|
||||
double vrate2 = 0;
|
||||
if(is_pal)
|
||||
vrate2 = 425568.0;
|
||||
else if(flags & FLAG_FRAMERATE)
|
||||
vrate2 = 357368.0;
|
||||
else
|
||||
vrate2 = 357366.0;
|
||||
vrate = sdmp_in.get_cpurate() / vrate2;
|
||||
std::cout << "Video frame rate is " << sdmp_in.get_cpurate() << "/" << vrate2 << "Hz" << std::endl;
|
||||
std::cout << "Wrote " << frames << " frames." << std::endl;
|
||||
std::cout << "Video length is " << frames / vrate << "s." << std::endl;
|
||||
}
|
||||
|
||||
void syntax()
|
||||
{
|
||||
std::cerr << "Syntax: sdump2sox [<options>] <input-file> <yuv-output-file> <sox-output-file> "
|
||||
<< "[<tc-output-file>]" << std::endl;
|
||||
std::cerr << "-W\tDump 512-wide instead of 256-wide." << std::endl;
|
||||
std::cerr << "-H\tDump 448/480-high instead of 224/240-high." << std::endl;
|
||||
std::cerr << "-D\tDedup the output (also uses exact timecodes)." << std::endl;
|
||||
std::cerr << "-h\tDump 512x448/480, doing blending for 512x224/240." << std::endl;
|
||||
std::cerr << "-F\tDump at interlaced framerate instead of non-interlaced (no effect if dedup)." << std::endl;
|
||||
std::cerr << "-l\tOffset timecodes by inserting 10 frames spanning 2 seconds (dedup only)." << std::endl;
|
||||
std::cerr << "-L\tOffset timecodes by 2 seconds (dedup only)." << std::endl;
|
||||
std::cerr << "-A\tDo output AR correction." << std::endl;
|
||||
std::cerr << "-f\tDump using full range instead of TV range." << std::endl;
|
||||
std::cerr << "-7\tDump using ITU.709 instead of ITU.601." << std::endl;
|
||||
std::cerr << "-2\tDump using SMPTE-240M instead of ITU.601." << std::endl;
|
||||
std::cerr << "-8\tDump using 8 bits instead of 16 bits." << std::endl;
|
||||
}
|
||||
|
||||
void reached_main();
|
||||
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
reached_main();
|
||||
if(argc < 4) {
|
||||
syntax();
|
||||
return 1;
|
||||
}
|
||||
uint32_t flags = 0;
|
||||
uint32_t idx1 = 0;
|
||||
uint32_t idx2 = 0;
|
||||
uint32_t idx3 = 0;
|
||||
uint32_t idx4 = 0;
|
||||
for(int i = 1; i < argc; i++) {
|
||||
if(argv[i][0] == '-')
|
||||
for(unsigned j = 1; argv[i][j]; j++)
|
||||
switch(argv[i][j]) {
|
||||
case 'W':
|
||||
flags |= FLAG_WIDTH;
|
||||
break;
|
||||
case 'H':
|
||||
flags |= FLAG_HEIGHT;
|
||||
break;
|
||||
case 'F':
|
||||
flags |= FLAG_FRAMERATE;
|
||||
break;
|
||||
case 'D':
|
||||
flags |= FLAG_DEDUP;
|
||||
break;
|
||||
case 'f':
|
||||
flags |= FLAG_FULLRANGE;
|
||||
break;
|
||||
case 'h':
|
||||
flags |= (FLAG_FAKENLARGE | FLAG_WIDTH | FLAG_HEIGHT);
|
||||
break;
|
||||
case 'l':
|
||||
flags |= (FLAG_10FRAMES | FLAG_OFFSET2);
|
||||
break;
|
||||
case 'L':
|
||||
flags |= FLAG_OFFSET2;
|
||||
break;
|
||||
case 'A':
|
||||
flags |= FLAG_AR_CORRECT;
|
||||
break;
|
||||
case '7':
|
||||
if(flags & FLAG_CS_MASK) {
|
||||
syntax();
|
||||
return 1;
|
||||
}
|
||||
flags |= FLAG_ITU709;
|
||||
break;
|
||||
case '2':
|
||||
if(flags & FLAG_CS_MASK) {
|
||||
syntax();
|
||||
return 1;
|
||||
}
|
||||
flags |= FLAG_SMPTE240M;
|
||||
break;
|
||||
case '8':
|
||||
flags |= FLAG_8BIT;
|
||||
break;
|
||||
default:
|
||||
syntax();
|
||||
return 1;
|
||||
}
|
||||
else if(!idx1)
|
||||
idx1 = i;
|
||||
else if(!idx2)
|
||||
idx2 = i;
|
||||
else if(!idx3)
|
||||
idx3 = i;
|
||||
else if(!idx4)
|
||||
idx4 = i;
|
||||
else {
|
||||
syntax();
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
if(idx4 && !(flags & FLAG_DEDUP)) {
|
||||
syntax();
|
||||
return 1;
|
||||
}
|
||||
std::ifstream in(argv[idx1], std::ios::in | std::ios::binary);
|
||||
if(!in) {
|
||||
std::cerr << "Error: Can't open '" << argv[idx1] << "'" << std::endl;
|
||||
return 2;
|
||||
}
|
||||
std::ofstream yout(argv[idx2], std::ios::out | std::ios::binary);
|
||||
if(!yout) {
|
||||
std::cerr << "Error: Can't open '" << argv[idx2] << "'" << std::endl;
|
||||
return 2;
|
||||
}
|
||||
std::ofstream sout(argv[idx3], std::ios::out | std::ios::binary);
|
||||
if(!sout) {
|
||||
std::cerr << "Error: Can't open '" << argv[idx3] << "'" << std::endl;
|
||||
return 2;
|
||||
}
|
||||
std::ofstream tout;
|
||||
if(flags & FLAG_DEDUP) {
|
||||
if(idx4)
|
||||
tout.open(argv[idx4], std::ios::out);
|
||||
else
|
||||
tout.open(argv[idx2] + std::string(".tc"), std::ios::out);
|
||||
if(!tout) {
|
||||
std::cerr << "Error: Can't open '" << argv[idx2] << ".tc'" << std::endl;
|
||||
return 2;
|
||||
}
|
||||
}
|
||||
try {
|
||||
sdump2sox(in, yout, sout, tout, flags);
|
||||
in.close();
|
||||
yout.close();
|
||||
sout.close();
|
||||
tout.close();
|
||||
} catch(std::exception& e) {
|
||||
std::cerr << "Error: " << e.what() << std::endl;
|
||||
in.close();
|
||||
yout.close();
|
||||
sout.close();
|
||||
tout.close();
|
||||
return 3;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,235 +0,0 @@
|
|||
#if defined(BSNES_V084) || defined(BSNES_V085) || defined(BSNES_V086) || defined(BSNES_V087)
|
||||
#include "lsnes.hpp"
|
||||
#include "core/advdumper.hpp"
|
||||
#include "core/dispatch.hpp"
|
||||
#include "core/moviedata.hpp"
|
||||
#include "interface/romtype.hpp"
|
||||
#include "library/serialization.hpp"
|
||||
#include "video/tcp.hpp"
|
||||
|
||||
#include <iomanip>
|
||||
#include <cassert>
|
||||
#include <cstring>
|
||||
#include <sstream>
|
||||
#include <zlib.h>
|
||||
#include <sstream>
|
||||
#include <fstream>
|
||||
#include <stdexcept>
|
||||
|
||||
#define CUTOFF 2100000000
|
||||
#define SDUMP_FLAG_HIRES 1
|
||||
#define SDUMP_FLAG_INTERLACED 2
|
||||
#define SDUMP_FLAG_OVERSCAN 4
|
||||
#define SDUMP_FLAG_PAL 8
|
||||
|
||||
namespace
|
||||
{
|
||||
void deleter_fn(void* f)
|
||||
{
|
||||
delete reinterpret_cast<std::ofstream*>(f);
|
||||
}
|
||||
|
||||
class sdmp_avsnoop : public information_dispatch
|
||||
{
|
||||
public:
|
||||
sdmp_avsnoop(const std::string& prefix, const std::string& mode) throw(std::bad_alloc,
|
||||
std::runtime_error)
|
||||
: information_dispatch("dump-sdmp")
|
||||
{
|
||||
enable_send_sound();
|
||||
oprefix = prefix;
|
||||
sdump_ss = (mode != "ms");
|
||||
ssize = 0;
|
||||
next_seq = 0;
|
||||
dumped_pic = false;
|
||||
if(mode == "tcp") {
|
||||
out = &(socket_address(prefix).connect());
|
||||
deleter = socket_address::deleter();
|
||||
} else {
|
||||
out = NULL;
|
||||
deleter = deleter_fn;
|
||||
}
|
||||
}
|
||||
|
||||
~sdmp_avsnoop() throw()
|
||||
{
|
||||
try {
|
||||
if(out)
|
||||
deleter(out);
|
||||
} catch(...) {
|
||||
}
|
||||
}
|
||||
|
||||
void on_raw_frame(const uint32_t* raw, bool hires, bool interlaced, bool overscan, unsigned region)
|
||||
{
|
||||
unsigned flags = 0;
|
||||
flags |= (hires ? SDUMP_FLAG_HIRES : 0);
|
||||
flags |= (interlaced ? SDUMP_FLAG_INTERLACED : 0);
|
||||
flags |= (overscan ? SDUMP_FLAG_OVERSCAN : 0);
|
||||
flags |= (region == VIDEO_REGION_PAL ? SDUMP_FLAG_PAL : 0);
|
||||
unsigned char tbuffer[2049];
|
||||
if(!out || (ssize > CUTOFF && !sdump_ss)) {
|
||||
std::cerr << "Starting new segment" << std::endl;
|
||||
if(out)
|
||||
deleter(out);
|
||||
std::ostringstream str;
|
||||
if(sdump_ss)
|
||||
str << oprefix;
|
||||
else
|
||||
str << oprefix << "_" << std::setw(4) << std::setfill('0') << (next_seq++)
|
||||
<< ".sdmp";
|
||||
std::string str2 = str.str();
|
||||
out = new std::ofstream(str2.c_str(), std::ios::out | std::ios::binary);
|
||||
if(!*out)
|
||||
throw std::runtime_error("Failed to open '" + str2 + "'");
|
||||
write32ube(tbuffer, 0x53444D50U);
|
||||
auto rates = our_rom->rtype->get_snes_rate();
|
||||
write32ube(tbuffer + 4, rates.first);
|
||||
write32ube(tbuffer + 8, rates.second);
|
||||
out->write(reinterpret_cast<char*>(tbuffer), 12);
|
||||
if(!*out)
|
||||
throw std::runtime_error("Failed to write header to '" + str2 + "'");
|
||||
ssize = 12;
|
||||
}
|
||||
dumped_pic = true;
|
||||
tbuffer[0] = flags;
|
||||
for(unsigned i = 0; i < 512; i++) {
|
||||
for(unsigned j = 0; j < 512; j++)
|
||||
write32ube(tbuffer + (4 * j + 1), raw[512 * i + j]);
|
||||
out->write(reinterpret_cast<char*>(tbuffer + (i ? 1 : 0)), i ? 2048 : 2049);
|
||||
}
|
||||
if(!*out)
|
||||
throw std::runtime_error("Failed to write frame");
|
||||
ssize += 1048577;
|
||||
}
|
||||
|
||||
void on_sample(short l, short r)
|
||||
{
|
||||
if(!out || !dumped_pic)
|
||||
return;
|
||||
unsigned char pkt[5];
|
||||
pkt[0] = 16;
|
||||
write16sbe(pkt + 1, l);
|
||||
write16sbe(pkt + 3, r);
|
||||
out->write(reinterpret_cast<char*>(pkt), 5);
|
||||
if(!*out)
|
||||
throw std::runtime_error("Failed to write sample");
|
||||
ssize += 5;
|
||||
}
|
||||
|
||||
void on_dump_end()
|
||||
{
|
||||
deleter(out);
|
||||
out = NULL;
|
||||
}
|
||||
|
||||
bool get_dumper_flag() throw()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
private:
|
||||
std::string oprefix;
|
||||
bool sdump_ss;
|
||||
bool dumped_pic;
|
||||
uint64_t ssize;
|
||||
uint64_t next_seq;
|
||||
void (*deleter)(void* f);
|
||||
std::ostream* out;
|
||||
};
|
||||
|
||||
sdmp_avsnoop* vid_dumper;
|
||||
|
||||
class adv_sdmp_dumper : public adv_dumper
|
||||
{
|
||||
public:
|
||||
adv_sdmp_dumper() : adv_dumper("INTERNAL-SDMP") { information_dispatch::do_dumper_update(); }
|
||||
~adv_sdmp_dumper() throw();
|
||||
std::set<std::string> list_submodes() throw(std::bad_alloc)
|
||||
{
|
||||
std::set<std::string> x;
|
||||
x.insert("ss");
|
||||
x.insert("ms");
|
||||
x.insert("tcp");
|
||||
return x;
|
||||
}
|
||||
|
||||
unsigned mode_details(const std::string& mode) throw()
|
||||
{
|
||||
if(mode == "ss")
|
||||
return target_type_file;
|
||||
if(mode == "ms")
|
||||
return target_type_prefix;
|
||||
if(mode == "tcp")
|
||||
return target_type_special;
|
||||
return target_type_mask;
|
||||
}
|
||||
|
||||
std::string mode_extension(const std::string& mode) throw()
|
||||
{
|
||||
return "sdmp"; //Ignored anyway in non-ss mode.
|
||||
}
|
||||
|
||||
std::string name() throw(std::bad_alloc)
|
||||
{
|
||||
return "SDMP";
|
||||
}
|
||||
|
||||
std::string modename(const std::string& mode) throw(std::bad_alloc)
|
||||
{
|
||||
if(mode == "ss")
|
||||
return "Single-Segment";
|
||||
if(mode == "ms")
|
||||
return "Multi-Segment";
|
||||
if(mode == "tcp")
|
||||
return "over TCP/IP";
|
||||
return "What?";
|
||||
}
|
||||
|
||||
bool busy()
|
||||
{
|
||||
return (vid_dumper != NULL);
|
||||
}
|
||||
|
||||
void start(const std::string& mode, const std::string& prefix) throw(std::bad_alloc,
|
||||
std::runtime_error)
|
||||
{
|
||||
if(prefix == "")
|
||||
throw std::runtime_error("Expected target");
|
||||
if(vid_dumper)
|
||||
throw std::runtime_error("SDMP Dump already in progress");
|
||||
try {
|
||||
vid_dumper = new sdmp_avsnoop(prefix, mode);
|
||||
} catch(std::bad_alloc& e) {
|
||||
throw;
|
||||
} catch(std::exception& e) {
|
||||
std::ostringstream x;
|
||||
x << "Error starting SDMP dump: " << e.what();
|
||||
throw std::runtime_error(x.str());
|
||||
}
|
||||
messages << "Dumping SDMP (" << mode << ") to " << prefix << std::endl;
|
||||
information_dispatch::do_dumper_update();
|
||||
}
|
||||
|
||||
void end() throw()
|
||||
{
|
||||
if(!vid_dumper)
|
||||
throw std::runtime_error("No SDMP video dump in progress");
|
||||
try {
|
||||
vid_dumper->on_dump_end();
|
||||
messages << "SDMP Dump finished" << std::endl;
|
||||
} catch(std::bad_alloc& e) {
|
||||
throw;
|
||||
} catch(std::exception& e) {
|
||||
messages << "Error ending SDMP dump: " << e.what() << std::endl;
|
||||
}
|
||||
delete vid_dumper;
|
||||
vid_dumper = NULL;
|
||||
information_dispatch::do_dumper_update();
|
||||
}
|
||||
} adv;
|
||||
|
||||
adv_sdmp_dumper::~adv_sdmp_dumper() throw()
|
||||
{
|
||||
}
|
||||
}
|
||||
#endif
|
||||
Loading…
Add table
Reference in a new issue