virtual void onDraw(SkCanvas* canvas) {
constexpr SkScalar kOffset = 35000.0f;
constexpr SkScalar kExtents = 1000.0f;
SkPictureRecorder recorder;
// We record a picture of huge vertical extents in which we clear the canvas to red, create
// a 'extents' by 'extents' round rect clip at a vertical offset of 'offset', then draw
// green into that.
SkCanvas* rec = recorder.beginRecording(kExtents, kOffset + kExtents, nullptr, 0);
rec->drawColor(SK_ColorRED);
rec->save();
SkRect r = SkRect::MakeXYWH(-kExtents, kOffset - kExtents, 2 * kExtents, 2 * kExtents);
SkPath p;
p.addRoundRect(r, 5, 5);
rec->clipPath(p, true);
rec->drawColor(SK_ColorGREEN);
rec->restore();
sk_sp<SkPicture> pict(recorder.finishRecordingAsPicture());
// Next we play that picture into another picture of the same size.
pict->playback(recorder.beginRecording(pict->cullRect().width(),
pict->cullRect().height(),
nullptr, 0));
sk_sp<SkPicture> pict2(recorder.finishRecordingAsPicture());
// Finally we play the part of that second picture that should be green into the canvas.
canvas->save();
canvas->translate(kExtents / 2, -(kOffset - kExtents / 2));
pict2->playback(canvas);
canvas->restore();
// If the image is red, we erroneously decided the clipPath was empty and didn't record
// the green drawColor, if it's green we're all good.
}
void onDrawContent(SkCanvas* canvas) override {
this->drawSomething(canvas);
SkPictureRecorder recorder;
this->drawSomething(recorder.beginRecording(100, 100, NULL, 0));
SkAutoTUnref<SkPicture> pict(recorder.endRecording());
canvas->save();
canvas->translate(SkIntToScalar(300), SkIntToScalar(50));
canvas->scale(-SK_Scalar1, -SK_Scalar1);
canvas->translate(-SkIntToScalar(100), -SkIntToScalar(50));
canvas->drawPicture(pict);
canvas->restore();
canvas->save();
canvas->translate(SkIntToScalar(200), SkIntToScalar(150));
canvas->scale(SK_Scalar1, -SK_Scalar1);
canvas->translate(0, -SkIntToScalar(50));
canvas->drawPicture(pict);
canvas->restore();
canvas->save();
canvas->translate(SkIntToScalar(100), SkIntToScalar(100));
canvas->scale(-SK_Scalar1, SK_Scalar1);
canvas->translate(-SkIntToScalar(100), 0);
canvas->drawPicture(pict);
canvas->restore();
}
void onDraw(SkCanvas* canvas) override {
SkPictureRecorder recorder;
SkCanvas* rec = recorder.beginRecording(1200, 900, nullptr, 0);
SkPath p;
SkRect r = {
SkIntToScalar(100),
SkIntToScalar(200),
SkIntToScalar(400),
SkIntToScalar(700)
};
p.addRoundRect(r, SkIntToScalar(50), SkIntToScalar(50));
rec->clipPath(p, SkRegion::kIntersect_Op, true);
rec->translate(SkIntToScalar(250), SkIntToScalar(250));
rec->clipPath(p, SkRegion::kIntersect_Op, true);
rec->drawColor(0xffff0000);
sk_sp<SkPicture> pict(recorder.finishRecordingAsPicture());
canvas->setAllowSimplifyClip(true);
canvas->save();
canvas->drawPicture(pict);
canvas->restore();
canvas->setAllowSimplifyClip(false);
canvas->save();
canvas->translate(SkIntToScalar(1200 / 2), 0);
canvas->drawPicture(pict);
canvas->restore();
}
QPixmap SoundUserConfig::makePixmap(const char *src)
{
const QPixmap &source = Pict(src);
int w = source.width();
int h = QMAX(source.height(), 22);
QPixmap pict(w, h);
QPainter p(&pict);
p.eraseRect(0, 0, w, h);
p.drawPixmap(0, (h - source.height()) / 2, source);
p.end();
return pict;
}
HRESULT TvideoCodecWmv9::decompress(const unsigned char *src,size_t srcLen,IMediaSample *pIn)
{
unsigned char *dst[4]= {NULL,NULL,NULL,NULL};
stride_t stride[4]= {0,0,0,0};
if (wmv9->decompress(src,srcLen,&dst[0],&stride[0])!=0 && dst[0]) {
if (pIn->IsPreroll()==S_OK) {
return sinkD->deliverPreroll(pIn->IsSyncPoint()?FRAME_TYPE::I:FRAME_TYPE::P);
}
TffPict pict(csp,dst,stride,rd,true,pIn);
return sinkD->deliverDecodedSample(pict);
} else {
return S_FALSE;
}
}
// Create a 'width' by 'height' skp with a 'border'-wide black border around
// a 'color' rectangle.
static void make_skp(SkScalar width, SkScalar height, SkScalar border, SkColor color,
const char *writePath) {
SkPictureRecorder recorder;
SkCanvas* canvas = recorder.beginRecording(width, height, NULL, 0);
SkPaint paint;
paint.setStyle(SkPaint::kFill_Style);
paint.setColor(SK_ColorBLACK);
SkRect r = SkRect::MakeWH(width, height);
canvas->drawRect(r, paint);
paint.setColor(color);
r.inset(border, border);
canvas->drawRect(r, paint);
SkAutoTUnref<SkPicture> pict(recorder.endRecording());
SkFILEWStream stream(writePath);
pict->serialize(&stream);
}
static void skpmaker(int width, int height, int border, SkColor color,
const char *writePath) {
SkPictureRecorder recorder;
SkCanvas* canvas = recorder.beginRecording(width, height, NULL, 0);
SkPaint paint;
paint.setStyle(SkPaint::kFill_Style);
paint.setColor(SK_ColorBLACK);
canvas->drawRectCoords(0, 0, SkIntToScalar(width), SkIntToScalar(height), paint);
paint.setColor(color);
canvas->drawRectCoords(SkIntToScalar(border), SkIntToScalar(border),
SkIntToScalar(width - border*2), SkIntToScalar(height - border*2),
paint);
SkAutoTUnref<SkPicture> pict(recorder.endRecording());
SkFILEWStream stream(writePath);
pict->serialize(&stream);
}
virtual void onDrawContent(SkCanvas* canvas) {
this->drawSomething(canvas);
SkPictureRecorder recorder;
this->drawSomething(recorder.beginRecording(100, 100, NULL, 0));
SkAutoTUnref<SkPicture> pict(recorder.endRecording());
canvas->save();
canvas->translate(SkIntToScalar(300), SkIntToScalar(50));
canvas->scale(-SK_Scalar1, -SK_Scalar1);
canvas->translate(-SkIntToScalar(100), -SkIntToScalar(50));
canvas->drawPicture(pict);
canvas->restore();
canvas->save();
canvas->translate(SkIntToScalar(200), SkIntToScalar(150));
canvas->scale(SK_Scalar1, -SK_Scalar1);
canvas->translate(0, -SkIntToScalar(50));
canvas->drawPicture(pict);
canvas->restore();
canvas->save();
canvas->translate(SkIntToScalar(100), SkIntToScalar(100));
canvas->scale(-SK_Scalar1, SK_Scalar1);
canvas->translate(-SkIntToScalar(100), 0);
canvas->drawPicture(pict);
canvas->restore();
#ifdef SK_DEVELOPER
if (false) {
SkDebugfDumper dumper;
SkDumpCanvas dumpCanvas(&dumper);
dumpCanvas.drawPicture(pict);
}
#endif
// This used to re-record the sub-picture and redraw the parent
// A capability that is now forbidden!
SkRandom rand(SampleCode::GetAnimTime());
canvas->translate(SkIntToScalar(10), SkIntToScalar(250));
canvas->drawPicture(fPicture);
delayInval(500);
}
void XYView_helper::draw(Canvas* c, const Allocation& a) const {
current_draw_view_ = v_;
((XYView_helper*)this)->t_ = c->transformer();
//print_t("XYView_helper::draw", c->transformer());
v_->set_damage_area(c);
#if 0
IfIdraw(pict(t_));
#else
if (OcIdraw::idraw_stream) {
Transformer tr(t_);
tr.translate(3*72, 4*72);
OcIdraw::pict(tr);
}
#endif
c->push_clipping();
c->clip_rect(v_->left(), v_->bottom(), v_->right(), v_->top());
body()->draw(c, a);
c->pop_clipping();
IfIdraw(end());
}
STDMETHODIMP TffProcVideo::processTime(unsigned int framenum,int64_t ref_start,int64_t ref_stop,uint64_t incsp,const unsigned char *src[4],stride_t srcStride[4],int ro,uint64_t Ioutcsp,unsigned char *Idst[4],stride_t IdstStride[4])
{
if (!Idst || !IdstStride) {
return S_FALSE;
}
Trect r=srcR;
TffPict pict(incsp,(unsigned char**)src,srcStride,r,!!ro,FRAME_TYPE::I,FIELD_TYPE::PROGRESSIVE_FRAME,0,NULL);
pict.rtStart=ref_start;
pict.rtStop=ref_stop;
outcsp=Ioutcsp;
dst=Idst;
dstStride=IdstStride;
HRESULT hr = processPict(framenum,pict,outcsp);
if (hr == S_OK) {
hr = deliverProcessedSample(pict);
} else {
if (!FAILED(hr)) {
hr = S_OK; // there wasn't anything wrong with the sample, we have just filtered it
}
}
return hr;
}
SplashPlugin::SplashPlugin(unsigned base, bool bStart)
: Plugin(base), EventReceiver(LowestPriority)
{
splash = NULL;
m_bStart = bStart;
if (m_bStart){
string pictPath = app_file("pict/splash.png");
QPixmap pict(QFile::decodeName(pictPath.c_str()));
if (!pict.isNull()){
splash = new QWidget(NULL, "splash",
QWidget::WType_TopLevel | QWidget::WStyle_Customize |
QWidget::WStyle_NoBorderEx | QWidget::WStyle_StaysOnTop);
splash->resize(pict.width(), pict.height());
QWidget *desktop = QApplication::desktop();
splash->move((desktop->width() - pict.width()) / 2, (desktop->height() - pict.height()) / 2);
splash->setBackgroundPixmap(pict);
const QBitmap *mask = pict.mask();
if (mask) splash->setMask(*mask);
splash->show();
}
}
}
static sk_sp<SkImageFilter> make_image_filter(bool canBeNull) {
sk_sp<SkImageFilter> filter;
// Add a 1 in 3 chance to get a nullptr input
uint8_t i;
fuzz->nextRange(&i, 0, 2);
if (fuzz->exhausted() || (canBeNull && i == 1)) {
return filter;
}
enum { ALPHA_THRESHOLD, MERGE, COLOR, BLUR, MAGNIFIER,
BLENDMODE, OFFSET, MATRIX, MATRIX_CONVOLUTION, COMPOSE,
DISTANT_LIGHT, POINT_LIGHT, SPOT_LIGHT, NOISE, DROP_SHADOW,
MORPHOLOGY, BITMAP, DISPLACE, TILE, PICTURE, PAINT, NUM_FILTERS };
uint8_t s;
fuzz->nextRange(&s, 0, NUM_FILTERS - 1);
switch (s) {
case ALPHA_THRESHOLD: {
SkRegion reg = make_region();
SkScalar innerMin, outerMax;
fuzz->next(&innerMin, &outerMax);
sk_sp<SkImageFilter> fil = make_image_filter();
filter = SkAlphaThresholdFilter::Make(reg, innerMin, outerMax, fil);
break;
}
case MERGE: {
sk_sp<SkImageFilter> filA = make_image_filter();
sk_sp<SkImageFilter> filB = make_image_filter();
filter = SkMergeImageFilter::Make(filA, filB);
break;
}
case COLOR: {
sk_sp<SkColorFilter> cf(make_color_filter());
filter = cf ? SkColorFilterImageFilter::Make(std::move(cf), make_image_filter())
: nullptr;
break;
}
case BLUR: {
SkScalar sX = make_number(true);
SkScalar sY = make_number(true);
sk_sp<SkImageFilter> fil = make_image_filter();
filter = SkBlurImageFilter::Make(sX, sY, fil);
break;
}
case MAGNIFIER: {
SkRect rect = make_rect();
SkScalar inset = make_number(true);
sk_sp<SkImageFilter> fil = make_image_filter();
filter = SkMagnifierImageFilter::Make(rect, inset, fil);
break;
}
case BLENDMODE: {
SkBlendMode mode = make_blendmode();
sk_sp<SkImageFilter> filA = make_image_filter();
sk_sp<SkImageFilter> filB = make_image_filter();
filter = SkXfermodeImageFilter::Make(mode, filA, filB, nullptr);
break;
}
case OFFSET: {
SkScalar dx, dy;
fuzz->next(&dx, &dy);
sk_sp<SkImageFilter> fil = make_image_filter();
filter = SkOffsetImageFilter::Make(dx, dy, fil);
break;
}
case MATRIX: {
SkMatrix m;
init_matrix(&m);
int qual;
fuzz->nextRange(&qual, 0, SkFilterQuality::kLast_SkFilterQuality - 1);
sk_sp<SkImageFilter> fil = make_image_filter();
filter = SkImageFilter::MakeMatrixFilter(m, (SkFilterQuality)qual, fil);
break;
}
case MATRIX_CONVOLUTION: {
SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize),
SkIntToScalar(kBitmapSize)));
int w, h;
fuzz->nextRange(&w, 1, 10);
fuzz->nextRange(&h, 1, 10);
SkISize size = SkISize::Make(w, h);
int arraySize = size.width() * size.height();
SkTArray<SkScalar> kernel(arraySize);
for (int i = 0; i < arraySize; ++i) {
kernel.push_back() = make_number(false);
}
fuzz->nextRange(&w, 0, size.width() - 1);
fuzz->nextRange(&h, 0, size.height() - 1);
SkIPoint kernelOffset = SkIPoint::Make(w, h);
int mode;
fuzz->nextRange(&mode, 0, SkMatrixConvolutionImageFilter::kMax_TileMode - 1);
bool convolveAlpha = make_bool();
SkScalar gain, bias;
fuzz->next(&gain, &bias);
sk_sp<SkImageFilter> fil = make_image_filter();
filter = SkMatrixConvolutionImageFilter::Make(size,
kernel.begin(),
gain,
bias,
kernelOffset,
(SkMatrixConvolutionImageFilter::TileMode)mode,
convolveAlpha,
fil,
&cropR);
break;
}
case COMPOSE: {
sk_sp<SkImageFilter> filA = make_image_filter();
sk_sp<SkImageFilter> filB = make_image_filter();
filter = SkComposeImageFilter::Make(filA, filB);
break;
}
case DISTANT_LIGHT: {
SkPoint3 p = make_point();
SkColor c = make_color();
SkScalar ss, kd;
fuzz->next(&ss, &kd);
int shininess;
fuzz->nextRange(&shininess, 0, 9);
sk_sp<SkImageFilter> fil = make_image_filter();
filter = make_bool()
? SkLightingImageFilter::MakeDistantLitDiffuse(p, c, ss, kd, fil)
: SkLightingImageFilter::MakeDistantLitSpecular(p, c, ss, kd, shininess, fil);
break;
}
case POINT_LIGHT: {
SkPoint3 p = make_point();
SkColor c = make_color();
SkScalar ss, kd;
fuzz->next(&ss, &kd);
int shininess;
fuzz->nextRange(&shininess, 0, 9);
sk_sp<SkImageFilter> fil = make_image_filter();
filter = make_bool()
? SkLightingImageFilter::MakePointLitDiffuse(p, c, ss, kd, fil)
: SkLightingImageFilter::MakePointLitSpecular(p, c, ss, kd, shininess, fil);
break;
}
case SPOT_LIGHT: {
SkPoint3 p = make_point();
SkColor c = make_color();
SkScalar se, ca, ss, kd;
fuzz->next(&se, &ca, &ss, &kd);
int shininess;
fuzz->nextRange(&shininess, 0, 9);
sk_sp<SkImageFilter> fil = make_image_filter();
filter = make_bool()
? SkLightingImageFilter::MakeSpotLitDiffuse(SkPoint3::Make(0, 0, 0),
p, se, ca, c, ss, kd, fil)
: SkLightingImageFilter::MakeSpotLitSpecular(SkPoint3::Make(0, 0, 0),
p, se, ca, c, ss, kd,
shininess, fil);
break;
}
case NOISE: {
SkScalar bfx = make_number(true);
SkScalar bfy = make_number(true);
SkScalar seed = make_number(false);
int octaves;
fuzz->nextRange(&octaves, 0, 9);
sk_sp<SkShader> shader(make_bool()
? SkPerlinNoiseShader::MakeFractalNoise(bfx, bfy, octaves, seed)
: SkPerlinNoiseShader::MakeTurbulence(bfx, bfy, octaves, seed));
SkPaint paint;
paint.setShader(shader);
SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize),
SkIntToScalar(kBitmapSize)));
filter = SkPaintImageFilter::Make(paint, &cropR);
break;
}
case DROP_SHADOW: {
SkScalar dx, dy, sx, sy;
fuzz->next(&dx, &dy);
sx = make_number(true);
sy = make_number(true);
SkColor c = make_color();
SkDropShadowImageFilter::ShadowMode mode = make_shadow_mode();
sk_sp<SkImageFilter> fil = make_image_filter();
filter = SkDropShadowImageFilter::Make(dx, dy, sx, sy, c, mode, fil, nullptr);
break;
}
case MORPHOLOGY: {
int rx, ry;
fuzz->nextRange(&rx, 0, kBitmapSize);
fuzz->nextRange(&ry, 0, kBitmapSize);
sk_sp<SkImageFilter> fil = make_image_filter();
if (make_bool()) {
filter = SkDilateImageFilter::Make(rx, ry, fil);
} else {
filter = SkErodeImageFilter::Make(rx, ry, fil);
}
break;
}
case BITMAP: {
sk_sp<SkImage> image(SkImage::MakeFromBitmap(make_bitmap()));
if (make_bool()) {
filter = SkImageSource::Make(std::move(image),
make_rect(),
make_rect(),
kHigh_SkFilterQuality);
} else {
filter = SkImageSource::Make(std::move(image));
}
break;
}
case DISPLACE: {
SkDisplacementMapEffect::ChannelSelectorType x = make_channel_selector_type();
SkDisplacementMapEffect::ChannelSelectorType y = make_channel_selector_type();
SkScalar scale = make_number(false);
sk_sp<SkImageFilter> filA = make_image_filter(false);
sk_sp<SkImageFilter> filB = make_image_filter();
filter = SkDisplacementMapEffect::Make(x, y, scale, filA, filB);
break;
}
case TILE: {
SkRect src = make_rect();
SkRect dest = make_rect();
sk_sp<SkImageFilter> fil = make_image_filter(false);
filter = SkTileImageFilter::Make(src, dest, fil);
break;
}
case PICTURE: {
SkRTreeFactory factory;
SkPictureRecorder recorder;
SkCanvas* recordingCanvas = recorder.beginRecording(SkIntToScalar(kBitmapSize),
SkIntToScalar(kBitmapSize),
&factory, 0);
drawSomething(recordingCanvas);
sk_sp<SkPicture> pict(recorder.finishRecordingAsPicture());
filter = SkPictureImageFilter::Make(pict, make_rect());
break;
}
case PAINT: {
SkImageFilter::CropRect cropR(make_rect());
filter = SkPaintImageFilter::Make(make_paint(), &cropR);
break;
}
default:
break;
}
return filter;
}
DEF_TEST(Serialization, reporter) {
// Test matrix serialization
{
SkMatrix matrix = SkMatrix::I();
TestObjectSerialization(&matrix, reporter);
}
// Test path serialization
{
SkPath path;
TestObjectSerialization(&path, reporter);
}
// Test region serialization
{
SkRegion region;
TestObjectSerialization(®ion, reporter);
}
// Test xfermode serialization
{
TestXfermodeSerialization(reporter);
}
// Test color filter serialization
{
TestColorFilterSerialization(reporter);
}
// Test string serialization
{
SkString string("string");
TestObjectSerializationNoAlign<SkString, false>(&string, reporter);
TestObjectSerializationNoAlign<SkString, true>(&string, reporter);
}
// Test rrect serialization
{
// SkRRect does not initialize anything.
// An uninitialized SkRRect can be serialized,
// but will branch on uninitialized data when deserialized.
SkRRect rrect;
SkRect rect = SkRect::MakeXYWH(1, 2, 20, 30);
SkVector corners[4] = { {1, 2}, {2, 3}, {3,4}, {4,5} };
rrect.setRectRadii(rect, corners);
TestAlignment(&rrect, reporter);
}
// Test readByteArray
{
unsigned char data[kArraySize] = { 1, 2, 3 };
TestArraySerialization(data, reporter);
}
// Test readColorArray
{
SkColor data[kArraySize] = { SK_ColorBLACK, SK_ColorWHITE, SK_ColorRED };
TestArraySerialization(data, reporter);
}
// Test readIntArray
{
int32_t data[kArraySize] = { 1, 2, 4, 8 };
TestArraySerialization(data, reporter);
}
// Test readPointArray
{
SkPoint data[kArraySize] = { {6, 7}, {42, 128} };
TestArraySerialization(data, reporter);
}
// Test readScalarArray
{
SkScalar data[kArraySize] = { SK_Scalar1, SK_ScalarHalf, SK_ScalarMax };
TestArraySerialization(data, reporter);
}
// Test invalid deserializations
{
SkImageInfo info = SkImageInfo::MakeN32Premul(kBitmapSize, kBitmapSize);
SkBitmap validBitmap;
validBitmap.setInfo(info);
// Create a bitmap with a really large height
SkBitmap invalidBitmap;
invalidBitmap.setInfo(info.makeWH(info.width(), 1000000000));
// The deserialization should succeed, and the rendering shouldn't crash,
// even when the device fails to initialize, due to its size
TestBitmapSerialization(validBitmap, invalidBitmap, true, reporter);
}
// Test simple SkPicture serialization
{
SkPictureRecorder recorder;
draw_something(recorder.beginRecording(SkIntToScalar(kBitmapSize),
SkIntToScalar(kBitmapSize),
nullptr, 0));
sk_sp<SkPicture> pict(recorder.finishRecordingAsPicture());
// Serialize picture
SkBinaryWriteBuffer writer;
pict->flatten(writer);
size_t size = writer.bytesWritten();
SkAutoTMalloc<unsigned char> data(size);
writer.writeToMemory(static_cast<void*>(data.get()));
// Deserialize picture
SkValidatingReadBuffer reader(static_cast<void*>(data.get()), size);
sk_sp<SkPicture> readPict(SkPicture::MakeFromBuffer(reader));
REPORTER_ASSERT(reporter, readPict.get());
}
TestPictureTypefaceSerialization(reporter);
// Test SkLightingShader/NormalMapSource serialization
{
const int kTexSize = 2;
SkLights::Builder builder;
builder.add(SkLights::Light(SkColor3f::Make(1.0f, 1.0f, 1.0f),
SkVector3::Make(1.0f, 0.0f, 0.0f)));
builder.add(SkLights::Light(SkColor3f::Make(0.2f, 0.2f, 0.2f)));
sk_sp<SkLights> fLights = builder.finish();
SkBitmap diffuse = sk_tool_utils::create_checkerboard_bitmap(
kTexSize, kTexSize,
sk_tool_utils::color_to_565(0x0),
sk_tool_utils::color_to_565(0xFF804020),
8);
SkRect bitmapBounds = SkRect::MakeIWH(diffuse.width(), diffuse.height());
SkMatrix matrix;
SkRect r = SkRect::MakeWH(SkIntToScalar(kTexSize), SkIntToScalar(kTexSize));
matrix.setRectToRect(bitmapBounds, r, SkMatrix::kFill_ScaleToFit);
SkMatrix ctm;
ctm.setRotate(45);
SkBitmap normals;
normals.allocN32Pixels(kTexSize, kTexSize);
sk_tool_utils::create_frustum_normal_map(&normals, SkIRect::MakeWH(kTexSize, kTexSize));
sk_sp<SkShader> normalMap = SkShader::MakeBitmapShader(normals, SkShader::kClamp_TileMode,
SkShader::kClamp_TileMode, &matrix);
sk_sp<SkNormalSource> normalSource = SkNormalSource::MakeFromNormalMap(std::move(normalMap),
ctm);
sk_sp<SkShader> diffuseShader = SkShader::MakeBitmapShader(diffuse,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, &matrix);
sk_sp<SkShader> lightingShader = SkLightingShader::Make(diffuseShader,
normalSource,
fLights);
SkAutoTUnref<SkShader>(TestFlattenableSerialization(lightingShader.get(), true, reporter));
lightingShader = SkLightingShader::Make(std::move(diffuseShader),
nullptr,
fLights);
SkAutoTUnref<SkShader>(TestFlattenableSerialization(lightingShader.get(), true, reporter));
lightingShader = SkLightingShader::Make(nullptr,
std::move(normalSource),
fLights);
SkAutoTUnref<SkShader>(TestFlattenableSerialization(lightingShader.get(), true, reporter));
lightingShader = SkLightingShader::Make(nullptr,
nullptr,
fLights);
SkAutoTUnref<SkShader>(TestFlattenableSerialization(lightingShader.get(), true, reporter));
}
// Test NormalBevelSource serialization
{
sk_sp<SkNormalSource> bevelSource = SkNormalSource::MakeBevel(
SkNormalSource::BevelType::kLinear, 2.0f, 5.0f);
SkAutoTUnref<SkNormalSource>(TestFlattenableSerialization(bevelSource.get(), true,
reporter));
// TODO test equality?
}
}
DEF_TEST(Serialization, reporter) {
// Test matrix serialization
{
SkMatrix matrix = SkMatrix::I();
TestObjectSerialization(&matrix, reporter);
}
// Test path serialization
{
SkPath path;
TestObjectSerialization(&path, reporter);
}
// Test region serialization
{
SkRegion region;
TestObjectSerialization(®ion, reporter);
}
// Test color filter serialization
{
TestColorFilterSerialization(reporter);
}
// Test string serialization
{
SkString string("string");
TestObjectSerializationNoAlign<SkString, false>(&string, reporter);
TestObjectSerializationNoAlign<SkString, true>(&string, reporter);
}
// Test rrect serialization
{
// SkRRect does not initialize anything.
// An uninitialized SkRRect can be serialized,
// but will branch on uninitialized data when deserialized.
SkRRect rrect;
SkRect rect = SkRect::MakeXYWH(1, 2, 20, 30);
SkVector corners[4] = { {1, 2}, {2, 3}, {3,4}, {4,5} };
rrect.setRectRadii(rect, corners);
SerializationTest::TestAlignment(&rrect, reporter);
}
// Test readByteArray
{
unsigned char data[kArraySize] = { 1, 2, 3 };
TestArraySerialization(data, reporter);
}
// Test readColorArray
{
SkColor data[kArraySize] = { SK_ColorBLACK, SK_ColorWHITE, SK_ColorRED };
TestArraySerialization(data, reporter);
}
// Test readColor4fArray
{
SkColor4f data[kArraySize] = {
SkColor4f::FromColor(SK_ColorBLACK),
SkColor4f::FromColor(SK_ColorWHITE),
SkColor4f::FromColor(SK_ColorRED),
{ 1.f, 2.f, 4.f, 8.f }
};
TestArraySerialization(data, reporter);
}
// Test readIntArray
{
int32_t data[kArraySize] = { 1, 2, 4, 8 };
TestArraySerialization(data, reporter);
}
// Test readPointArray
{
SkPoint data[kArraySize] = { {6, 7}, {42, 128} };
TestArraySerialization(data, reporter);
}
// Test readScalarArray
{
SkScalar data[kArraySize] = { SK_Scalar1, SK_ScalarHalf, SK_ScalarMax };
TestArraySerialization(data, reporter);
}
// Test invalid deserializations
{
SkImageInfo info = SkImageInfo::MakeN32Premul(kBitmapSize, kBitmapSize);
SkBitmap validBitmap;
validBitmap.setInfo(info);
// Create a bitmap with a really large height
SkBitmap invalidBitmap;
invalidBitmap.setInfo(info.makeWH(info.width(), 1000000000));
// The deserialization should succeed, and the rendering shouldn't crash,
// even when the device fails to initialize, due to its size
TestBitmapSerialization(validBitmap, invalidBitmap, true, reporter);
}
// Test simple SkPicture serialization
{
SkPictureRecorder recorder;
draw_something(recorder.beginRecording(SkIntToScalar(kBitmapSize),
SkIntToScalar(kBitmapSize),
nullptr, 0));
sk_sp<SkPicture> pict(recorder.finishRecordingAsPicture());
// Serialize picture
SkBinaryWriteBuffer writer;
pict->flatten(writer);
size_t size = writer.bytesWritten();
SkAutoTMalloc<unsigned char> data(size);
writer.writeToMemory(static_cast<void*>(data.get()));
// Deserialize picture
SkReadBuffer reader(static_cast<void*>(data.get()), size);
sk_sp<SkPicture> readPict(SkPicture::MakeFromBuffer(reader));
REPORTER_ASSERT(reporter, reader.isValid());
REPORTER_ASSERT(reporter, readPict.get());
}
TestPictureTypefaceSerialization(reporter);
}
void FloatyWnd::paintEvent(QPaintEvent*)
{
int w = width() - 4;
int h = height() - 4;
QPixmap pict(w, h);
QPainter p(&pict);
p.fillRect(QRect(0, 0, width(), height()), colorGroup().base());
PaintView pv;
pv.p = &p;
pv.pos = QPoint(2, 2);
pv.size = QSize(w, h);
pv.win = this;
pv.isStatic = false;
pv.height = h;
if (m_plugin->core->getUseSysColors()){
p.setPen(colorGroup().text());
}else{
p.setPen(QColor(m_plugin->core->getColorOnline()));
}
Event e(EventPaintView, &pv);
e.process();
if (m_plugin->core->getUseSysColors()){
if (m_status != STATUS_ONLINE)
p.setPen(palette().disabled().text());
}else{
switch (m_status){
case STATUS_ONLINE:
p.setPen(m_plugin->core->getColorOnline());
break;
case STATUS_AWAY:
p.setPen(m_plugin->core->getColorAway());
break;
case STATUS_NA:
p.setPen(m_plugin->core->getColorNA());
break;
case STATUS_DND:
p.setPen(m_plugin->core->getColorDND());
break;
default:
p.setPen(m_plugin->core->getColorOffline());
break;
}
}
int x = 0;
const char *statusIcon = m_statusIcon;
if (m_unread && m_plugin->m_bBlink){
CommandDef *def = m_plugin->core->messageTypes.find(m_unread);
if (def)
statusIcon = def->icon;
}
if (statusIcon){
const QPixmap &pict = Pict(statusIcon).pixmap();
x += 2;
p.drawPixmap(x, (h - pict.height()) / 2, pict);
x += pict.width() + 2;
}
QRect br;
setFont(&p);
p.drawText(x, 0, w, h, Qt::AlignLeft | Qt::AlignVCenter, m_text, -1, &br);
x = br.right() + 5;
string icons = m_icons;
while (icons.length()){
string icon = getToken(icons, ',');
const QPixmap &pict = Pict(icon.c_str()).pixmap();
x += 2;
p.drawPixmap(x, (h - pict.height()) / 2, pict);
x += pict.width();
}
p.end();
p.begin(this);
p.drawPixmap(QPoint(2, 2), pict);
p.setPen(colorGroup().dark());
p.drawLine(1, 1, width() - 2, 1);
p.drawLine(1, 1, width() - 2, height() - 2);
p.drawLine(1, 1, 1, height() - 2);
p.setPen(colorGroup().shadow());
p.drawLine(0, height() - 1, width() - 1, height() - 1);
p.drawLine(0, height() - 1, width() - 1, 1);
p.drawLine(width() - 3, 2, 2, 2);
p.drawLine(width() - 3, 2, 2, height() - 3);
p.setPen(colorGroup().light());
p.drawLine(2, height() - 3, width() - 3, height() - 3);
p.drawLine(2, height() - 3, width() - 3, 2);
p.drawLine(width() - 1, 0, 0, 0);
p.drawLine(width() - 1, 0, 0, height() - 1);
}
int main( int argc, char **argv )
{
bmpreader pict(argv[1]);//实例一个bmp读取类，获得相应的信息头和像素数据，并根据不同大小的像素位进行填充图像
BYTE KeyInput[16];//输入的密钥，传送走的密钥
double pk[16];//迭代前的各个盒子值
double nk[16];//迭代后的各个盒子值
int picH = pict.picH;
int picW = pict.picW;//原始图的高宽
int picS = pict.csize;//填充后的整体大小
int bnum = pict.Bnum;//分块数
int eachtime = picS/bnum;
printf("each time = %d Num = %d\n",eachtime,bnum);
//BYTE RL[eachtime];//每次的随机序列
//RL 得变成double的了。。方便运算么
cout<<"Please input a Keyline...(16byte-128bit)"<<endl;
cout<<"1234567890123456<-Here the ending is.."<<endl;
cin>>KeyInput;
//获得x初始盒子，迭代times次，消除。。
Xprod(KeyInput,pk);
NKProd(pk,nk,500);
//然后产生随机序列并映射到（-0.5，0.5）直接利用混沌盒子的值！？yes!!(8x4-8x2+1)~(-1,1)的，直接处理出来就好了
BYTE BK[eachtime];
double YUV[eachtime];
double rla[eachtime];
double rlb[eachtime];
double L[eachtime];
double R[eachtime];
MatrixXd Lym(8,8);
MatrixXd Rym(8,8);
MatrixXd Lum(8,8);
MatrixXd Rum(8,8);
MatrixXd Lvm(8,8);
MatrixXd Rvm(8,8);
MatrixXd Xym(8,8);
MatrixXd Xum(8,8);
MatrixXd Xvm(8,8);
MatrixXd Yym(8,8);
MatrixXd Yum(8,8);
MatrixXd Yvm(8,8);
for(int k = 0 ; k < bnum ; k++){
memcpy(BK,pict.PicS+k*eachtime,eachtime);
//RGB to YUV
RtoY(BK,YUV,eachtime);
//一次产生a b 以计算出L & R
rlProd(pk,nk,rla,eachtime);
rlProd(pk,nk,rlb,eachtime);
//L&R
LProd(rla,L);
RProd(rlb,R);
for(int i=0;i<8;i++){
for(int j=0;j<8;j++){
Xym(i,j) = YUV[3*(8*i+j)+0];
Xum(i,j) = YUV[3*(8*i+j)+1];
Xvm(i,j) = YUV[3*(8*i+j)+2];
Lym(i,j) = L[3*(8*i+j)+0];
Lum(i,j) = L[3*(8*i+j)+1];
Lvm(i,j) = L[3*(8*i+j)+2];
Rym(i,j) = R[3*(8*i+j)+0];
Rum(i,j) = R[3*(8*i+j)+1];
Rvm(i,j) = R[3*(8*i+j)+2];
}
}//得到YUV三个分量的X矩阵,3个L&R
Yym = Lym*Xym*Rym;
Yum = Lum*Xum*Rum;
Yvm = Lvm*Xvm*Rvm;
/*if(k%100 == 0){
cout<<Lym<<endl<<Lum<<endl<<Lvm<<endl<<Rym<<endl<<Rum<<endl<<Rvm<<endl;
cout<<k<<"::"<<endl<<"yym:"<<endl<<Yym<<endl<<"yum:"<<endl<<Yum<<endl<<"yvm:"<<endl<<Yvm<<endl;
}*/
}
return 0;
}
static SkImageFilter* make_image_filter(bool canBeNull) {
SkImageFilter* filter = 0;
// Add a 1 in 3 chance to get a nullptr input
if (canBeNull && (R(3) == 1)) { return filter; }
enum { ALPHA_THRESHOLD, MERGE, COLOR, LUT3D, BLUR, MAGNIFIER,
DOWN_SAMPLE, XFERMODE, OFFSET, MATRIX, MATRIX_CONVOLUTION, COMPOSE,
DISTANT_LIGHT, POINT_LIGHT, SPOT_LIGHT, NOISE, DROP_SHADOW,
MORPHOLOGY, BITMAP, DISPLACE, TILE, PICTURE, PAINT, NUM_FILTERS };
switch (R(NUM_FILTERS)) {
case ALPHA_THRESHOLD:
filter = SkAlphaThresholdFilter::Create(make_region(), make_scalar(), make_scalar());
break;
case MERGE:
filter = SkMergeImageFilter::Create(make_image_filter(), make_image_filter(), make_xfermode());
break;
case COLOR:
{
SkAutoTUnref<SkColorFilter> cf(make_color_filter());
filter = cf.get() ? SkColorFilterImageFilter::Create(cf, make_image_filter()) : 0;
}
break;
case LUT3D:
{
int cubeDimension;
SkAutoDataUnref lut3D(make_3Dlut(&cubeDimension, (R(2) == 1), (R(2) == 1), (R(2) == 1)));
SkAutoTUnref<SkColorFilter> cf(SkColorCubeFilter::Create(lut3D, cubeDimension));
filter = cf.get() ? SkColorFilterImageFilter::Create(cf, make_image_filter()) : 0;
}
break;
case BLUR:
filter = SkBlurImageFilter::Create(make_scalar(true), make_scalar(true), make_image_filter());
break;
case MAGNIFIER:
filter = SkMagnifierImageFilter::Create(make_rect(), make_scalar(true));
break;
case DOWN_SAMPLE:
filter = SkDownSampleImageFilter::Create(make_scalar());
break;
case XFERMODE:
{
SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(make_xfermode()));
filter = SkXfermodeImageFilter::Create(mode, make_image_filter(), make_image_filter());
}
break;
case OFFSET:
filter = SkOffsetImageFilter::Create(make_scalar(), make_scalar(), make_image_filter());
break;
case MATRIX:
filter = SkImageFilter::CreateMatrixFilter(make_matrix(),
(SkFilterQuality)R(4),
make_image_filter());
break;
case MATRIX_CONVOLUTION:
{
SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize),
SkIntToScalar(kBitmapSize)));
SkISize size = SkISize::Make(R(10)+1, R(10)+1);
int arraySize = size.width() * size.height();
SkTArray<SkScalar> kernel(arraySize);
for (int i = 0; i < arraySize; ++i) {
kernel.push_back() = make_scalar();
}
SkIPoint kernelOffset = SkIPoint::Make(R(SkIntToScalar(size.width())),
R(SkIntToScalar(size.height())));
filter = SkMatrixConvolutionImageFilter::Create(size,
kernel.begin(),
make_scalar(),
make_scalar(),
kernelOffset,
(SkMatrixConvolutionImageFilter::TileMode)R(3),
R(2) == 1,
make_image_filter(),
&cropR);
}
break;
case COMPOSE:
filter = SkComposeImageFilter::Create(make_image_filter(), make_image_filter());
break;
case DISTANT_LIGHT:
filter = (R(2) == 1) ?
SkLightingImageFilter::CreateDistantLitDiffuse(make_point(),
make_color(), make_scalar(), make_scalar(), make_image_filter()) :
SkLightingImageFilter::CreateDistantLitSpecular(make_point(),
make_color(), make_scalar(), make_scalar(), SkIntToScalar(R(10)),
make_image_filter());
break;
case POINT_LIGHT:
filter = (R(2) == 1) ?
SkLightingImageFilter::CreatePointLitDiffuse(make_point(),
make_color(), make_scalar(), make_scalar(), make_image_filter()) :
SkLightingImageFilter::CreatePointLitSpecular(make_point(),
make_color(), make_scalar(), make_scalar(), SkIntToScalar(R(10)),
make_image_filter());
break;
case SPOT_LIGHT:
filter = (R(2) == 1) ?
SkLightingImageFilter::CreateSpotLitDiffuse(SkPoint3::Make(0, 0, 0),
make_point(), make_scalar(), make_scalar(), make_color(),
make_scalar(), make_scalar(), make_image_filter()) :
SkLightingImageFilter::CreateSpotLitSpecular(SkPoint3::Make(0, 0, 0),
make_point(), make_scalar(), make_scalar(), make_color(),
make_scalar(), make_scalar(), SkIntToScalar(R(10)), make_image_filter());
break;
case NOISE:
{
SkAutoTUnref<SkShader> shader((R(2) == 1) ?
SkPerlinNoiseShader::CreateFractalNoise(
make_scalar(true), make_scalar(true), R(10.0f), make_scalar()) :
SkPerlinNoiseShader::CreateTurbulence(
make_scalar(true), make_scalar(true), R(10.0f), make_scalar()));
SkPaint paint;
paint.setShader(shader);
SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize),
SkIntToScalar(kBitmapSize)));
filter = SkPaintImageFilter::Create(paint, &cropR);
}
break;
case DROP_SHADOW:
filter = SkDropShadowImageFilter::Create(make_scalar(), make_scalar(), make_scalar(true),
make_scalar(true), make_color(), make_shadow_mode(), make_image_filter(),
nullptr);
break;
case MORPHOLOGY:
if (R(2) == 1) {
filter = SkDilateImageFilter::Create(R(static_cast<float>(kBitmapSize)),
R(static_cast<float>(kBitmapSize)), make_image_filter());
} else {
filter = SkErodeImageFilter::Create(R(static_cast<float>(kBitmapSize)),
R(static_cast<float>(kBitmapSize)), make_image_filter());
}
break;
case BITMAP:
{
SkAutoTUnref<SkImage> image(SkImage::NewFromBitmap(make_bitmap()));
if (R(2) == 1) {
filter = SkImageSource::Create(image, make_rect(), make_rect(), kHigh_SkFilterQuality);
} else {
filter = SkImageSource::Create(image);
}
}
break;
case DISPLACE:
filter = SkDisplacementMapEffect::Create(make_channel_selector_type(),
make_channel_selector_type(), make_scalar(),
make_image_filter(false), make_image_filter());
break;
case TILE:
filter = SkTileImageFilter::Create(make_rect(), make_rect(), make_image_filter(false));
break;
case PICTURE:
{
SkRTreeFactory factory;
SkPictureRecorder recorder;
SkCanvas* recordingCanvas = recorder.beginRecording(SkIntToScalar(kBitmapSize),
SkIntToScalar(kBitmapSize),
&factory, 0);
drawSomething(recordingCanvas);
SkAutoTUnref<SkPicture> pict(recorder.endRecording());
filter = SkPictureImageFilter::Create(pict.get(), make_rect());
}
break;
case PAINT:
{
SkImageFilter::CropRect cropR(make_rect());
filter = SkPaintImageFilter::Create(make_paint(), &cropR);
}
default:
break;
}
return (filter || canBeNull) ? filter : make_image_filter(canBeNull);
}
DEF_TEST(Serialization, reporter) {
// Test matrix serialization
{
SkMatrix matrix = SkMatrix::I();
TestObjectSerialization(&matrix, reporter);
}
// Test path serialization
{
SkPath path;
TestObjectSerialization(&path, reporter);
}
// Test region serialization
{
SkRegion region;
TestObjectSerialization(®ion, reporter);
}
// Test rrect serialization
{
// SkRRect does not initialize anything.
// An uninitialized SkRRect can be serialized,
// but will branch on uninitialized data when deserialized.
SkRRect rrect;
SkRect rect = SkRect::MakeXYWH(1, 2, 20, 30);
SkVector corners[4] = { {1, 2}, {2, 3}, {3,4}, {4,5} };
rrect.setRectRadii(rect, corners);
TestAlignment(&rrect, reporter);
}
// Test readByteArray
{
unsigned char data[kArraySize] = { 1, 2, 3 };
TestArraySerialization(data, reporter);
}
// Test readColorArray
{
SkColor data[kArraySize] = { SK_ColorBLACK, SK_ColorWHITE, SK_ColorRED };
TestArraySerialization(data, reporter);
}
// Test readIntArray
{
int32_t data[kArraySize] = { 1, 2, 4, 8 };
TestArraySerialization(data, reporter);
}
// Test readPointArray
{
SkPoint data[kArraySize] = { {6, 7}, {42, 128} };
TestArraySerialization(data, reporter);
}
// Test readScalarArray
{
SkScalar data[kArraySize] = { SK_Scalar1, SK_ScalarHalf, SK_ScalarMax };
TestArraySerialization(data, reporter);
}
// Test invalid deserializations
{
SkImageInfo info = SkImageInfo::MakeN32Premul(kBitmapSize, kBitmapSize);
SkBitmap validBitmap;
validBitmap.setConfig(info);
// Create a bitmap with a really large height
info.fHeight = 1000000000;
SkBitmap invalidBitmap;
invalidBitmap.setConfig(info);
// The deserialization should succeed, and the rendering shouldn't crash,
// even when the device fails to initialize, due to its size
TestBitmapSerialization(validBitmap, invalidBitmap, true, reporter);
}
// Test simple SkPicture serialization
{
SkPictureRecorder recorder;
bool didDraw = drawSomething(recorder.beginRecording(kBitmapSize, kBitmapSize));
REPORTER_ASSERT(reporter, didDraw);
SkAutoTUnref<SkPicture> pict(recorder.endRecording());
// Serialize picture
SkWriteBuffer writer(SkWriteBuffer::kValidation_Flag);
pict->flatten(writer);
size_t size = writer.bytesWritten();
SkAutoTMalloc<unsigned char> data(size);
writer.writeToMemory(static_cast<void*>(data.get()));
// Deserialize picture
SkValidatingReadBuffer reader(static_cast<void*>(data.get()), size);
SkAutoTUnref<SkPicture> readPict(
SkPicture::CreateFromBuffer(reader));
REPORTER_ASSERT(reporter, NULL != readPict.get());
}
}
void run()
{
quit = false;
CL_DisplayWindowDescription window_desc;
window_desc.set_size(CL_Size(1920, 1080), true);
window_desc.set_title("Luna");
CL_DisplayWindow window(window_desc);
CL_Slot slot_quit = window.sig_window_close().connect(this, &RootWindow::on_window_close);
CL_GraphicContext gc = window.get_gc();
CL_InputDevice keyboard = window.get_ic().get_keyboard();
CL_FontDescription font_desc;
font_desc.set_typeface_name("Monospace");
font_desc.set_height(16);
CL_Font_System font(gc, font_desc);
CL_FontMetrics fmetrics = font.get_font_metrics();
int fntWidth = fmetrics.get_max_character_width();
CL_SpriteDescription spr_desc;
spr_desc.add_frame(CL_ImageProviderFactory::load("spaceship.png"));
CL_Sprite node(gc, spr_desc);
node.set_play_loop(true);
node.set_play_pingpong(false);
node.set_frame(0);
CL_Image pict(gc,"stars.jpg");
x = gc.get_width() / 2 ;
y = gc.get_height() / 2 ;
U = 0;
W = 0;
V = 0;
H = 0;
step = 0.2;
while (!quit)
{
if(keyboard.get_keycode(CL_KEY_ESCAPE) == true)
quit = true;
if(keyboard.get_keycode(CL_KEY_LEFT) == true)
U -= step ;
if(keyboard.get_keycode(CL_KEY_RIGHT) == true)
U += step ;
if(keyboard.get_keycode(CL_KEY_UP) == true)
V -= step ;
if(keyboard.get_keycode(CL_KEY_DOWN) == true)
V += step ;
if(x < -node.get_width()) {
x = gc.get_width();
}
else if(x > gc.get_width()) {
x = -node.get_width();
}
else
x += U ;
if(y < step) {
y = step;
V = 0;
}
else if(y > gc.get_height()-node.get_height()) {
y = gc.get_height()-node.get_height();
V = 0;
}
else
y += V;
gc.clear();
pict.draw(gc,W,H);
pict.draw(gc,W,H-gc.get_height() );
pict.draw(gc,W-gc.get_width(),H );
H++ ;
if( H > gc.get_height() ) H = 0;
node.draw(gc, x, y);
CL_String velocity = cl_format("Velocity U[%1] V[%2] --- Coordinate X[%3] Y[%4] --- Origin W[%5] H[%6]",U,V,x,y,W,H);
font.draw_text(gc, gc.get_width()/2 - (velocity.length() * fntWidth)/2, 16, velocity);
window.flip();
CL_KeepAlive::process();
CL_System::sleep(10);
}
}
HRESULT TvideoCodecLibmpeg2::decompressI(const unsigned char *src,size_t srcLen,IMediaSample *pIn)
{
TffdshowVideoInputPin::TrateAndFlush *rateInfo = (TffdshowVideoInputPin::TrateAndFlush*)deciV->getRateInfo();
if (pIn->IsDiscontinuity() == S_OK) {
rateInfo->isDiscontinuity = true;
}
REFERENCE_TIME rtStart=REFTIME_INVALID,rtStop=_I64_MIN;
HRESULT hr_GetTime = pIn->GetTime(&rtStart,&rtStop);
if (FAILED(hr_GetTime)) {
rtStart=rtStop=REFTIME_INVALID;
}
int len=(int)srcLen;
while (len>=0) {
mpeg2_state_t state=mpeg2_parse(mpeg2dec);
switch (state) {
case STATE_BUFFER: {
if (len==0) {
len=-1;
} else {
mpeg2_buffer(mpeg2dec,src,src+len);
len=0;
}
break;
}
case STATE_INVALID:
break;
case STATE_GOP: {
if(rateInfo->rate.Rate == 10000
&& mpeg2dec->info.user_data_len > 4
&& *(DWORD*)mpeg2dec->info.user_data == 0xf8014343) {
if (!ccDecoder) {
ccDecoder=new TccDecoder(deciV);
}
ccDecoder->decode(mpeg2dec->info.user_data+2,mpeg2dec->info.user_data_len-2);
}
break;
}
case STATE_SEQUENCE: {
sequenceFlag=FIELD_TYPE::SEQ_START;
avgTimePerFrame=10LL*info->sequence->frame_period/27;
deciV->setAverageTimePerFrame(&avgTimePerFrame,true);
break;
}
case STATE_PICTURE: {
mpeg2dec->decoder.quant_stride=quantsStride=quantsDx=(info->sequence->picture_width+15)>>4;
quantsDy=(info->sequence->picture_height+15)>>4;
quants=mpeg2dec->decoder.quant_store=(char*)realloc(quants, quantsStride*quantsDy*2);
quantType=1;
// Remove const cast
mpeg2_picture_t* CurrentPicture = (mpeg2_picture_t*)mpeg2_info(mpeg2dec)->current_picture;
// skip preroll pictures as well as non I frames during ff or rew
if(pIn->IsPreroll()==S_OK || (rateInfo->rate.Rate < (10000 / TffdshowVideoInputPin::MAX_SPEED) && (CurrentPicture->flags&PIC_MASK_CODING_TYPE) != PIC_FLAG_CODING_TYPE_I)) {
// DPRINTF(_l("Skip preroll frame\n"));
rateInfo->isDiscontinuity = true;
CurrentPicture->flags |= PIC_FLAG_SKIP;
}
mpeg2_set_rtStart(mpeg2dec,rtStart);
rtStart=REFTIME_INVALID;
break;
}
case STATE_END:
sequenceFlag |= FIELD_TYPE::SEQ_END;
case STATE_SLICE:
if (info->display_picture && info->discard_fbuf && !(info->display_picture->flags&PIC_FLAG_SKIP)) {
{
int frametype;
if (info->sequence->flags&SEQ_FLAG_MPEG2) {
quantType=FF_QSCALE_TYPE_MPEG2;
}
switch (info->display_picture->flags&PIC_MASK_CODING_TYPE) {
case PIC_FLAG_CODING_TYPE_I:
frametype=FRAME_TYPE::I;
break;
case PIC_FLAG_CODING_TYPE_B:
frametype=FRAME_TYPE::B;
break;
default:
case PIC_FLAG_CODING_TYPE_P:
frametype=FRAME_TYPE::P;
break;
}
if (frametype==FRAME_TYPE::I) {
wait4Iframe=false;
}
if (pIn->IsPreroll()==S_OK) {
return sinkD->deliverPreroll(frametype);
}
int fieldtype = SetDeinterlaceMethod();
if (sequenceFlag != FIELD_TYPE::SEQ_START || frametype == FRAME_TYPE::I) {
fieldtype|=sequenceFlag;
sequenceFlag=0;
}
unsigned char *data[4]= {info->display_fbuf->buf[0],info->display_fbuf->buf[1],info->display_fbuf->buf[2],NULL};
stride_t stride[4]= {info->sequence->width,info->sequence->chroma_width,info->sequence->chroma_width,0};
uint64_t csp;
switch ((info->sequence->chroma_width==info->sequence->width)+(info->sequence->chroma_height==info->sequence->height)) {
case 1:
csp=FF_CSP_422P;
break;
case 2:
csp=FF_CSP_444P;
break;
default:
case 0:
csp=FF_CSP_420P;
break;
}
Trect r(0,0,info->sequence->picture_width,info->sequence->picture_height);
r.sar = Rational(info->sequence->pixel_width,info->sequence->pixel_height);
// Correct impossible sar for DVD
if (info->sequence->flags & SEQ_FLAG_MPEG2) {
r.sar = guessMPEG2sar(r, Rational(info->sequence->pixel_width2,info->sequence->pixel_height2), containerSar);
}
TffPict pict(csp,data,stride,r,true,frametype,fieldtype,srcLen,NULL); //TODO: src frame size
pict.film = m_fFilm;
if(frametype == FRAME_TYPE::I) {
pict.rtStart = info->display_picture->rtStart;
} else {
pict.rtStart = oldpict.rtStop;
}
// cope with a change in rate
if (rateInfo->rate.Rate != rateInfo->ratechange.Rate
&& rateInfo->flushed
&& frametype == FRAME_TYPE::I) {
// Buggy DVD navigator does not work as it is documented.
// DPRINTF(_l("rateInfo->ratechange.StartTime = %s rateInfo->rate.StartTime = %s rateInfo->rate.Rate %d"), Trt2str(rateInfo->ratechange.StartTime).c_str(),Trt2str(rateInfo->rate.StartTime).c_str(),rateInfo->rate.Rate);
rateInfo->rate.StartTime = pict.rtStart;
rateInfo->rate.Rate = rateInfo->ratechange.Rate;
rateInfo->isDiscontinuity = true;
// DPRINTF(_l("Got Rate StartTime = %s Rate = %d\n"), Trt2str(rateInfo->rate.StartTime).c_str(), rateInfo->rate.Rate);
}
if ((rateInfo->isDiscontinuity || rateInfo->correctTS) && frametype == FRAME_TYPE::I) {
// if we're at a Discontinuity use the times we're being sent in
// DPRINTF((ffstring(L"rateInfo->isDiscontinuity found. pict.rtStart ") + Trt2str(pict.rtStart) + L" rateInfo->rate.StartTime " + Trt2str(rateInfo->rate.StartTime)).c_str());
pict.rtStart = rateInfo->rate.StartTime + (pict.rtStart - rateInfo->rate.StartTime) * abs(rateInfo->rate.Rate) / 10000;
// DPRINTF(_l("rateInfo->isDiscontinuity found. updating rtStart %s oldpict.rtStop %s"),Trt2str(pict.rtStart).c_str(), Trt2str(oldpict.rtStop).c_str());
pict.discontinuity = rateInfo->isDiscontinuity;
rateInfo->isDiscontinuity = false;
} else {
pict.rtStart = oldpict.rtStop;
}
unsigned int field_count = 2;
if (info->display_picture->flags & PIC_FLAG_REPEAT_FIRST_FIELD) {
field_count++;
}
if (rateInfo->rate.Rate < (10000 / TffdshowVideoInputPin::MAX_SPEED)) {
pict.rtStop = pict.rtStart + avgTimePerFrame;
} else
pict.rtStop = pict.rtStart +
(avgTimePerFrame * field_count * abs(rateInfo->rate.Rate) / (2 * 10000));
if (rateInfo->rate.Rate < (10000 / TffdshowVideoInputPin::MAX_SPEED)) {
pict.fieldtype |= FIELD_TYPE::SEQ_START | FIELD_TYPE::SEQ_END;
}
oldpict=pict;
if (rateInfo->isDiscontinuity) {
telecineManager.onSeek();
}
// soft telecine detection
// if "Detect soft telecine and average frame durations" is enabled,
// flames are flagged as progressive, frame durations are averaged.
// pict.film is valid even if the setting is disabled.
telecineManager.new_frame(
!!(info->display_picture->flags & PIC_FLAG_TOP_FIELD_FIRST),
!!(info->display_picture->flags & PIC_FLAG_REPEAT_FIRST_FIELD),
pict.rtStart,
pict.rtStop);
}
if (!wait4Iframe) {
TffPict pict(oldpict);
telecineManager.get_fieldtype(pict);
telecineManager.get_timestamps(pict);
HRESULT hr = sinkD->deliverDecodedSample(pict);
if (hr != S_OK) {
return hr;
}
}
// else DPRINTF(_l("libmpeg2: waiting for keyframe"));
}
break;
}
}
return S_OK;
}
HRESULT TvideoCodecQuickSync::DeliverSurface(QsFrameData* frameData)
{
if (NULL == frameData) { return E_POINTER; }
unsigned char* dstBuffer[4] = {frameData->y, frameData->u, 0, 0};
ptrdiff_t strides[4] = {frameData->dwStride, frameData->dwStride, 0, 0};
int frametype, fieldtype;
// set frame type - Not curently available!
switch (frameData->frameType) {
case QsFrameData::P:
frametype = FRAME_TYPE::P;
break;
case QsFrameData::B:
frametype = FRAME_TYPE::B;
break;
case QsFrameData::I:
default:
frametype = FRAME_TYPE::I;
}
// interlacing info
// progressive
if (frameData->dwInterlaceFlags & AM_VIDEO_FLAG_WEAVE) {
fieldtype = FIELD_TYPE::PROGRESSIVE_FRAME;
}
// interlaced
else {
fieldtype = (frameData->dwInterlaceFlags & AM_VIDEO_FLAG_FIELD1FIRST) ?
(FIELD_TYPE::INT_TFF) :
(FIELD_TYPE::INT_BFF);
}
Trect r(frameData->rcClip);
TffPict pict(FF_CSP_NV12, dstBuffer, strides, r, frameData->bReadOnly, frametype, fieldtype, 0, NULL); //TODO: src frame size
pict.rectClip = frameData->rcClip;
// set times stamps
pict.rtStart = frameData->rtStart;
pict.rtStop = frameData->rtStop;
// aspect ratio
if (frameData->dwPictAspectRatioX * frameData->dwPictAspectRatioY != 0) {
Rational dar(frameData->dwPictAspectRatioX, frameData->dwPictAspectRatioY);
pict.setDar(dar);
}
// soft telecine detection
// if "Detect soft telecine and average frame durations" is enabled,
// flames are flagged as progressive, frame durations are averaged.
// pict.film is valid even if the setting is disabled.
telecineManager.new_frame(
0 != (frameData->dwInterlaceFlags & AM_VIDEO_FLAG_FIELD1FIRST),
0 != (frameData->dwInterlaceFlags & AM_VIDEO_FLAG_REPEAT_FIELD),
pict.rtStart,
pict.rtStop);
telecineManager.get_fieldtype(pict);
telecineManager.get_timestamps(pict);
return sinkD->deliverDecodedSample(pict);
}
