HandBrake | HandBrake's main development repository | Video Utils library

This is a simple procedure and can be implemented in one funciton.

For Handbrake, you use the veryfast preset.
You can also specify a preset with ffmpeg, by default it is set to medium but you can change:
-preset veryfast

Your problem wasn't quite condensed enough to reproduce, or to see the desired output, but your basic approach is fine. You may run into issues with misspellings, in which case maybe use an edit distance with a threshold for determining whether to take out the stopword. Here's my version of your code that seems to do fine

You don't need the looping. From the documentation:

The word_tokenize function returns a list of tokens. You therefore need a second for-loop or a list comprehension:

This is happening because of the inheritance, basically; inheritance isn't a concept that protobuf directly supports, so protobuf-net models inheritance via nested sub-objects; to avoid some complexity, when serializing this, protobuf-net always starts by writing the inheritance parts first - so: when serializing BasePaintHolder, it might serialize field 400 (the sub-type data for BaseSmokePaintHolder), then field 1 (materialId). This means that when it comes to deserialize, it has an obvious construction path, i.e. by the time it gets field data, it has already constructed the final concrete type.

This is fine, for protobuf-net to protobuf-net scenarios, but when we work with the same data in Java, it doesn't know or care about this, and elects to serialize in ascending field order, i.e. field 1, then field 400. It is explicit in the specification that fields may be out of order, but Java can choose to do whatever it wants.

So: now we take that data back to protobuf-net, and we see field 1 first; at that point, we have no clue what the final type will be, and nowhere (yet) to stick the data. With no better options, the library tries to use the base type BasePaintHolder as a placeholder until it can make better decisions, but it turns out that this type is abstract, so: even that fails.

So: that's the why, and some back-story. What can we do?

Well, the first thing we could try might be to remove the abstract, making it technically constructable. To prevent external code accidentally creating instances, you might also make the constructors protected, internal, or private protected (which means the intersection of protected and internal). We could also try using the SkipConstructor=true modifier on [ProtoContract].

If that doesn't work: it might be necessary to basically work with 2 different object models; one that is simple - essentially more like the Java version, perhaps by running your schema through https://protogen.marcgravell.com/ - and one that has the inheritance; use the simple version for deserialization (and optionally serialization, although that shouldn't matter), and then re-map the data in your own code to the actual model. The other option is for me to figure out a way of doing all this magically and automatically; which: isn't a small job.

The damage to the video file could be at any point so to check it you unfortunately have to go through the entire video.

Possibly the quickest approach would be to use ffmpeg - if you ask it to re-encode a video to null it should simply read in the file, reporting any errors that it finds and then ignore each frame it has read. As it is doing very little work other than decode it should be quite quick.

You can test on a known working and a known broken file first to ensure it catches your errors:

./ffmpeg -v error -I yourVideoFile.mp4 -f null - 2>error.log

Have a look at some of the discussion here to get a feeling for other approaches and also wrapping into a script: https://superuser.com/a/338708

What is the "Source" you expect?

I'm not sure but maybe you can handle it by javascript.

In html, just show that former video, then when user interact with this, you can redircet to latter video.

It seems you can use pyenchant library:

Enchant is used to check the spelling of words and suggest corrections for words that are miss-spelled. It can use many popular spellchecking packages to perform this task, including ispell, aspell and MySpell. It is quite flexible at handling multiple dictionaries and multiple languages.

More information is available on the Enchant website:

https://abiword.github.io/enchant/

Sample Python code: