static void uninit(struct sd *sd)
{
struct sd_ass_priv *ctx = sd->priv;
if (ctx->converter)
lavc_conv_uninit(ctx->converter);
ass_free_track(ctx->ass_track);
ass_free_track(ctx->shadow_track);
enable_output(sd, false);
ass_library_done(ctx->ass_library);
}
int main(int argc, char *argv[])
{
const int frame_w = 640;
const int frame_h = 480;
if (argc < 4) {
printf("usage: %s <image file> <subtitle file> <time>\n", argv[0]);
exit(1);
}
char *imgfile = argv[1];
char *subfile = argv[2];
double tm = strtod(argv[3], 0);
init(frame_w, frame_h);
ASS_Track *track = ass_read_file(ass_library, subfile, NULL);
if (!track) {
printf("track init failed!\n");
return 1;
}
ASS_Image *img =
ass_render_frame(ass_renderer, track, (int) (tm * 1000), NULL);
image_t *frame = gen_image(frame_w, frame_h);
blend(frame, img);
ass_free_track(track);
ass_renderer_done(ass_renderer);
ass_library_done(ass_library);
write_png(imgfile, frame);
return 0;
}
void dvbsub_ass_clear(void)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> m_lock(ass_mutex);
while(ass_queue.size()) {
ass_data *a = (ass_data *) ass_queue.pop();
if (a) {
avsubtitle_free(&a->sub);
delete a;
}
}
while(!sem_trywait(&ass_sem));
ass_track = NULL;
for(std::map<int,ASS_Track*>::iterator it = ass_map.begin(); it != ass_map.end(); ++it)
ass_free_track(it->second);
ass_map.clear();
if (ass_renderer) {
ass_renderer_done(ass_renderer);
ass_renderer = NULL;
}
if (ass_library) {
ass_library_done(ass_library);
ass_library = NULL;
}
clear_queue();
}
static void uninit(struct sh_sub *sh)
{
struct sd_ass_priv *ctx = sh->context;
ass_free_track(ctx->ass_track);
talloc_free(ctx);
}
CDVDSubtitlesLibass::~CDVDSubtitlesLibass()
{
if(m_track)
ass_free_track(m_track);
ass_renderer_done(m_renderer);
ass_library_done(m_library);
}
static void uninit(struct sd *sd)
{
struct sd_ass_priv *ctx = sd->priv;
ass_free_track(ctx->ass_track);
talloc_free(ctx);
}
static void VS_CC assFree(void *instanceData, VSCore *core, const VSAPI *vsapi)
{
AssData *d = (AssData *)instanceData;
vsapi->freeNode(d->node);
ass_renderer_done(d->ass_renderer);
ass_library_done(d->ass_library);
ass_free_track(d->ass);
free(d);
}
/// @brief Load subtitles
/// @param subs
///
void LibassSubtitlesProvider::LoadSubtitles(AssFile *subs) {
// Prepare subtitles
std::vector<char> data;
subs->SaveMemory(data);
// Load file
if (ass_track) ass_free_track(ass_track);
ass_track = ass_read_memory(ass_library, &data[0], data.size(),(char *)"UTF-8");
if (!ass_track) throw "libass failed to load subtitles.";
}
void LibASS::closeOSD()
{
if (osd_renderer)
ass_renderer_done(osd_renderer);
if (osd_track)
ass_free_track(osd_track);
osd_track = NULL;
osd_style = NULL;
osd_event = NULL;
osd_renderer = NULL;
}
static av_cold void uninit(AVFilterContext *ctx)
{
AssContext *ass = ctx->priv;
if (ass->track)
ass_free_track(ass->track);
if (ass->renderer)
ass_renderer_done(ass->renderer);
if (ass->library)
ass_library_done(ass->library);
}
bool SubtitleProcessorLibASS::process(const QString &path)
{
if (!ass::api::loaded())
return false;
if (m_track) {
ass_free_track(m_track);
m_track = 0;
}
m_track = ass_read_file(m_ass, (char*)path.toUtf8().constData(), NULL);
if (!m_track) {
qWarning("ass_read_file error, ass track init failed!");
return false;
}
processTrack(m_track);
return true;
}
void LibASS::closeASS()
{
while (ass_sub_styles_copy.size())
{
ASS_Style *style = ass_sub_styles_copy.takeFirst();
if (style->FontName)
free(style->FontName);
delete style;
}
if (ass_sub_renderer)
ass_renderer_done(ass_sub_renderer);
if (ass_sub_track)
ass_free_track(ass_sub_track);
ass_sub_track = NULL;
ass_sub_renderer = NULL;
}
SubtitleProcessorLibASS::~SubtitleProcessorLibASS()
{
if (!ass::api::loaded())
return;
if (m_track) {
ass_free_track(m_track);
m_track = 0;
}
if (m_renderer) {
ass_renderer_done(m_renderer);
m_renderer = 0;
}
if (m_ass) {
ass_library_done(m_ass);
m_ass = 0;
}
}
static void DecSysRelease( decoder_sys_t *p_sys )
{
/* */
vlc_mutex_lock( &p_sys->lock );
p_sys->i_refcount--;
if( p_sys->i_refcount > 0 )
{
vlc_mutex_unlock( &p_sys->lock );
return;
}
vlc_mutex_unlock( &p_sys->lock );
vlc_mutex_destroy( &p_sys->lock );
vlc_mutex_lock( &libass_lock );
if( p_sys->p_track )
ass_free_track( p_sys->p_track );
vlc_mutex_unlock( &libass_lock );
AssHandleRelease( p_sys->p_ass );
free( p_sys );
}
static void DecSysRelease( decoder_sys_t *p_sys )
{
/* */
vlc_mutex_lock( &p_sys->lock );
p_sys->i_refcount--;
if( p_sys->i_refcount > 0 )
{
vlc_mutex_unlock( &p_sys->lock );
return;
}
vlc_mutex_unlock( &p_sys->lock );
vlc_mutex_destroy( &p_sys->lock );
if( p_sys->p_track )
ass_free_track( p_sys->p_track );
if( p_sys->p_renderer )
ass_renderer_done( p_sys->p_renderer );
if( p_sys->p_library )
ass_library_done( p_sys->p_library );
free( p_sys );
}
bool SubtitleProcessorLibASS::process(QIODevice *dev)
{
if (!ass::api::loaded())
return false;
if (m_track) {
ass_free_track(m_track);
m_track = 0;
}
if (!dev->isOpen()) {
if (!dev->open(QIODevice::ReadOnly)) {
qWarning() << "open qiodevice error: " << dev->errorString();
return false;
}
}
QByteArray data(dev->readAll());
m_track = ass_read_memory(m_ass, (char*)data.constData(), data.size(), NULL); //utf-8
if (!m_track) {
qWarning("ass_read_memory error, ass track init failed!");
return false;
}
processTrack(m_track);
return true;
}
void BigPotSubtitleAss::closeSubtitle()
{
if (_track)
ass_free_track(_track);
_track = nullptr;
}
/// @brief Destructor
///
LibassSubtitlesProvider::~LibassSubtitlesProvider() {
if (ass_track) ass_free_track(ass_track);
if (ass_renderer) ass_renderer_done(ass_renderer);
}
void csri_close(csri_inst *inst)
{
ass_free_track(inst->ass_track);
ass_renderer_done(inst->ass_renderer);
free(inst);
}
int main(int argc, char *argv[])
{
POINT mouse;
//while (true)
{
GetCursorPos(&mouse);
printf("\r%d-%d ", mouse.x, mouse.y);
}
return interlace_RGB();
return matrix();
// char URI[] = "//mnt/sdcard/%E9%98%BF%E4%B8%BD%E4%BA%9A%E5%A8%9C%E5%90%89%E5%88%A9%E6%96%AF-%20Shake%E8%8B%B9%E6%9E%9C.3dv";
char URI[] = "//mnt/sdcard/HELLO!.3dv";
char decoded_URI[1024];
URIDecode(URI, decoded_URI, sizeof(decoded_URI));
char k = 0xef;
bool a = k == 0xef;
const int frame_w = 1920;
const int frame_h = 1080;
setlocale(LC_ALL, "CHS");
if (argc < 4) {
printf("usage: %s <image file> <subtitle file> <time>\n", argv[0]);
exit(1);
}
char *imgfile = argv[1];
char *subfile = argv[2];
double tm = strtod(argv[3], 0);
FILE * f = fopen(subfile, "rb");
fseek(f, 0, SEEK_END);
int file_size = ftell(f);
fseek(f, 0, SEEK_SET);
char *src = (char*)malloc(file_size);
char *utf8 = (char*)malloc(file_size*3);
fread(src, 1, file_size, f);
fclose(f);
int utf8_size = ConvertToUTF8(src, file_size, utf8, file_size*3);
ass_library = ass_library_init();
if (!ass_library) {
printf("ass_library_init failed!\n");
exit(1);
}
//ass_set_message_cb(ass_library, msg_callback, NULL);
//ass_set_extract_fonts(ass_library, 0);
//ass_set_style_overrides(ass_library, NULL);
ass_renderer = ass_renderer_init(ass_library);
if (!ass_renderer) {
printf("ass_renderer_init failed!\n");
exit(1);
}
ass_set_frame_size(ass_renderer, frame_w, frame_h);
ass_set_font_scale(ass_renderer, 1.0);
//ass_set_hinting(ass_renderer, ASS_HINTING_NORMAL);
ass_set_fonts(ass_renderer, "Arial", "Sans", 1, "Z:\\fonts.conf", 1);
ASS_Track *track = ass_read_memory(ass_library, utf8, utf8_size, NULL);
free(src);
free(utf8);
if (!track) {
printf("track init failed!\n");
return 1;
}
ASS_Image *img = NULL;
int n = 0;
int changed = 0;
image_t *frame = gen_image(frame_w, frame_h);
int n2 = 0;
int l = GetTickCount();
timeBeginPeriod(1);
for(int i=0; i<int(tm*1000); i+=40)
{
img = ass_render_frame(ass_renderer, track, i, &changed);
if (n==0) l = GetTickCount();
if (changed && img)
{
int l = timeGetTime();
n++;
memset(frame->buffer, 63, frame->stride * frame->height);
blend(frame, img);
wchar_t pathname[MAX_PATH];
wsprintfW(pathname, L"Z:\\ass%02d.bmp", n);
save_bitmap((DWORD*)frame->buffer, pathname, frame_w, frame_h);
//printf("\rrender cost %dms.\t\t\n", timeGetTime()-l);
}
n2 ++;
if (i%10000 == 0)
printf("\r%d/%d ms rendered, %d frame output.", i, int(tm*1000), n);
}
ass_free_track(track);
ass_renderer_done(ass_renderer);
ass_library_done(ass_library);
free(frame->buffer);
free(frame);
return 0;
}
