void FFMPEGV_Real_Init()
{
nodedef Def;
const codecinfo* i;
avcodec_init();
/* video codecs */
REGISTER_DECODER (RV10, rv10);
REGISTER_DECODER (RV20, rv20);
REGISTER_DECODER (RV30, rv30);
REGISTER_DECODER (RV40, rv40);
NodeRegisterClass(&FFMPEGRealVideo);
memset(&Def,0,sizeof(Def));
for (i=Info;i->Id;++i)
{
StringAdd(1,i->Id,NODE_NAME,i->Name);
StringAdd(1,i->Id,NODE_CONTENTTYPE,i->ContentType);
Def.Class = i->Id;
Def.ParentClass = FFMPEG_VIDEO_REAL_CLASS;
Def.Priority = PRI_DEFAULT-10; // do not override ARM optimized codecs by default
Def.Flags = 0; // parent size
NodeRegisterClass(&Def);
}
}
void NodeAddModule(const tchar_t* Path,int Id,int64_t Date,bool_t Load,bool_t Tmp)
{
context* p = Context();
LockEnter(p->NodeLock);
if (ArrayAppend(&p->NodeModule,NULL,sizeof(nodemodule),256))
{
int No = ARRAYCOUNT(p->NodeModule,nodemodule)-1;
nodemodule* Module = ARRAYBEGIN(p->NodeModule,nodemodule)+No;
memset(Module,0,sizeof(nodemodule));
Module->Id = Id;
Module->Date = Date;
Module->Tmp = Tmp;
StringAdd(1,MODULE_PATH,No,Path);
if (Load)
{
p->LoadModuleNo = No;
Module->Module = NodeLoadModule(Path,&Module->Id,&Module->Func,&Module->Db);
p->LoadModuleNo = 0;
#ifdef PLUGINCLEANUP
FreeModule(Module);
#endif
}
}
LockLeave(p->NodeLock);
}
static Replace *
ReplaceRead (FILE *f)
{
int c;
Replace *r;
while ((c = getc (f)) != '@')
{
if (c == EOF)
return 0;
}
r = ReplaceNew();
while ((c = getc (f)) != '@')
{
if (c == EOF)
{
ReplaceDispose (r);
return 0;
}
if (isspace (c))
Bail ("invalid character after tag %s", r->tag->buf);
StringAdd (r->tag, c);
}
if (r->tag->buf[0] == '\0')
{
ReplaceDispose (r);
return 0;
}
while (isspace ((c = getc (f))))
;
ungetc (c, f);
while ((c = getc (f)) != '@' && c != EOF)
StringAdd (r->text, c);
if (c == '@')
ungetc (c, f);
while (isspace (StringLast (r->text)))
StringDel (r->text);
return r;
}
bool isAdditiveNumberHelper(string& n1, string& n2, string& n3){
string add = StringAdd(n1, n2);
if (add.size() > n3.size()) return false;
if (add == n3 ) return true;
//split the n3 to 2 parts, and keep going.
string cut = n3.substr(0, add.size());
if (add == cut) {
string rest = n3.substr(add.size());
return isAdditiveNumberHelper(n2, add, rest);
}
return false;
}
static ReplaceSet *
ReplaceSetRead (FILE *f)
{
ReplaceSet *s = ReplaceSetNew ();
Replace *r;
while ((r = ReplaceRead (f)))
{
while (ReplaceSetFind (s, r->tag->buf))
StringAdd (r->tag, '+');
ReplaceSetAdd (s, r);
}
if (!s->head)
{
ReplaceSetDispose (s);
s = 0;
}
return s;
}
static LoopStack *
LoopStackLoop (ReplaceSet *rs, LoopStack *ls, FILE *f)
{
String *s = StringMake (ls->tag->buf);
LoopStack *ret = ls;
Bool loop;
StringAdd (ls->extra, '+');
StringAddString (s, ls->extra->buf);
loop = ReplaceSetFind (rs, s->buf) != 0;
StringDispose (s);
if (loop)
fseek (f, ls->pos, SEEK_SET);
else
{
ret = ls->prev;
StringDispose (ls->tag);
StringDispose (ls->extra);
Dispose (ls);
}
return ret;
}
void FFMPEGV_Init()
{
nodedef Def;
const codecinfo* i;
avcodec_init();
/* video codecs */
REGISTER_DECODER (FLV, flv);
REGISTER_DECODER (AVS, avs);
REGISTER_DECODER (CAVS, cavs);
REGISTER_DECODER (CINEPAK, cinepak);
REGISTER_DECODER (H261, h261);
REGISTER_DECODER (H263, h263);
REGISTER_DECODER (H263I, h263i);
REGISTER_DECODER (H264, h264);
REGISTER_DECODER (INDEO2, indeo2);
REGISTER_DECODER (INDEO3, indeo3);
REGISTER_DECODER (MPEG2VIDEO, mpeg2video);
REGISTER_DECODER (MPEG4, mpeg4);
REGISTER_DECODER (MSMPEG4V1, msmpeg4v1);
REGISTER_DECODER (MSMPEG4V2, msmpeg4v2);
REGISTER_DECODER (MSMPEG4V3, msmpeg4v3);
REGISTER_DECODER (MSRLE, msrle);
REGISTER_DECODER (MSVIDEO1, msvideo1);
REGISTER_DECODER (RV10, rv10);
REGISTER_DECODER (RV20, rv20);
REGISTER_DECODER (RV30, rv30);
REGISTER_DECODER (RV40, rv40);
//REGISTER_DECODER (sp5x);
REGISTER_DECODER (SVQ1, svq1);
REGISTER_DECODER (SVQ3, svq3);
REGISTER_DECODER (THEORA, theora);
REGISTER_DECODER (VC1, vc1);
REGISTER_DECODER (VP3, vp3);
REGISTER_DECODER (VP5, vp5);
REGISTER_DECODER (VP6, vp6);
REGISTER_DECODER (VP6A, vp6a);
REGISTER_DECODER (VP6F, vp6f);
REGISTER_DECODER (VP8, vp8);
REGISTER_DECODER (WMV1, wmv1);
REGISTER_DECODER (WMV2, wmv2);
REGISTER_DECODER (WMV3, wmv3);
REGISTER_DECODER (TSCC, tscc);
/* register_avcodec(&flv_decoder);
register_avcodec(&mpeg1video_decoder);
register_avcodec(&mpeg2video_decoder);
register_avcodec(&mpegvideo_decoder);
// register_avcodec(&svq1_decoder);
register_avcodec(&svq3_decoder);
register_avcodec(&h263_decoder);
register_avcodec(&mpeg4_decoder);
register_avcodec(&msmpeg4v1_decoder);
register_avcodec(&msmpeg4v2_decoder);
register_avcodec(&msmpeg4v3_decoder);
register_avcodec(&wmv1_decoder);
register_avcodec(&wmv2_decoder);
// register_avcodec(&wmv3_decoder);
register_avcodec(&h264_decoder);
register_avcodec(&cinepak_decoder);
register_avcodec(&msvideo1_decoder);
register_avcodec(&tscc_decoder);
*/
NodeRegisterClass(&FFMPEGVideo);
memset(&Def,0,sizeof(Def));
for (i=Info;i->Id;++i)
{
StringAdd(1,i->Id,NODE_NAME,i->Name);
StringAdd(1,i->Id,NODE_CONTENTTYPE,i->ContentType);
Def.Class = i->Id;
Def.ParentClass = FFMPEG_VIDEO_CLASS;
Def.Priority = PRI_DEFAULT-10; // do not override ARM optimized codecs by default
Def.Flags = 0; // parent size
if ((i->CodecId == CODEC_ID_WMV1 && QueryPlatform(PLATFORM_WMPVERSION)!=10) || //WMP10 RGB only output -> prefer ffmpeg
i->CodecId == CODEC_ID_WMV2 ||
i->CodecId == CODEC_ID_WMV3)
Def.Priority -= 100; // prefer DMO, WMV2 J-frames are not supported by ffmpeg, WMMX support by MS codecs are faster
NodeRegisterClass(&Def);
}
NodeRegisterClass(&WMVF);
}
OBJECT_ID BinaryOp(OBJECT_ID tos_id,OBJECT_ID tos1_id,unsigned char op)
{
object *tos = (object*)mem_lock(tos_id);
object *tos1 = (object*)mem_lock(tos1_id);
OBJECT_ID new_tos_id = 0;
if(tos->type == TYPE_UNICODE && tos1->type == TYPE_UNICODE && op == OPCODE_BINARY_ADD) //string add -> returns string
{
mem_unlock(tos1_id,0);
mem_unlock(tos_id,0);
return(StringAdd(tos1_id,tos_id));
}
if(tos->type == TYPE_INT && tos1->type == TYPE_UNICODE && op == OPCODE_BINARY_MULTIPLY) //unicode multiply -> returns unicode
{
//printf("string multiply\n");
mem_unlock(tos1_id,0);
mem_unlock(tos_id,0);
return(StringMultiply(tos1_id,tos_id));
}
if(tos->type == TYPE_INT && tos1->type == TYPE_TUPLE && op == OPCODE_BINARY_MULTIPLY) //tuple multiply -> returns tuple
{
NUM a =(NUM) ((int_object*)tos)->value;
NUM mnum = tuple_GetLen(tos1_id);
if(mnum == 1)
{
OBJECT_ID old = tos1_id;
tos1_id = tuple_GetItem(tos1_id,0);
mem_unlock(old,0);//TODO what if tos1_id == old .... ???????
tos1 = (object*)mem_lock(tos1_id);
}
TUPLE_ID mtr = obj_CreateTuple(a);
for(NUM i = 0; i < a; i++)
{
tuple_SetItem(mtr,i,tos1_id);
}
#ifdef USE_DEBUGGING
if((debug_level & DEBUG_VERBOSE_STEP) > 0)
obj_Dump(mtr,0,1);
#endif
mem_unlock(tos1_id,0);
mem_unlock(tos_id,0);
return(mtr);
}
if(tos->type == TYPE_BINARY_FLOAT || tos1->type == TYPE_BINARY_FLOAT) //mixed op -> returns float
{
FLOAT af = 0.0f;
FLOAT bf = 0.0f;
//printf("float ret\n");
if(tos->type == TYPE_INT)
//if (tos1->type == TYPE_INT)
{
af = (FLOAT) ((int_object*)tos)->value;
//af = (FLOAT) ((int_object*)tos1)->value;
}
if(tos1->type == TYPE_INT)
//if (tos->type == TYPE_INT)
{
bf = (FLOAT) ((int_object*)tos1)->value;
//bf = (FLOAT) ((int_object*)tos)->value;
}
if(tos->type == TYPE_BINARY_FLOAT)
//if (tos1->type == TYPE_BINARY_FLOAT)
{
af = ((float_object*)tos)->value;
//af = ((float_object*)tos1)->value;
}
if(tos1->type == TYPE_BINARY_FLOAT)
//if (tos->type == TYPE_BINARY_FLOAT)
{
bf = ((float_object*)tos1)->value;
//bf = ((float_object*)tos)->value;
}
mem_unlock(tos1_id,0);
mem_unlock(tos_id,0);
new_tos_id = obj_CreateFloat(0);
float_object *new_tos = (float_object*)mem_lock(new_tos_id);
switch(op)
{
case OPCODE_INPLACE_MULTIPLY:
case OPCODE_BINARY_MULTIPLY:
{
new_tos->value = bf * af;
#ifdef USE_DEBUGGING
debug_printf(DEBUG_VERBOSE_STEP,"%7g * %7g = %7g\n", bf, af, bf * af);
#endif
}
break;
case OPCODE_INPLACE_OR:
case OPCODE_BINARY_OR:
{
new_tos->value = (long)bf | (long)af;
#ifdef USE_DEBUGGING
debug_printf(DEBUG_VERBOSE_STEP,"%7g | %7g = %7g\n", bf, af, (long)bf | (long)af);
#endif
}
break;
case OPCODE_INPLACE_XOR:
case OPCODE_BINARY_XOR:
{
new_tos->value = (long)bf ^ (long)af;
#ifdef USE_DEBUGGING
debug_printf(DEBUG_VERBOSE_STEP,"%7g ^ %7g = %7g\n", bf, af, (long)bf ^ (long)af);
#endif
}
break;
case OPCODE_INPLACE_AND:
case OPCODE_BINARY_AND:
{
new_tos->value = (long)bf & (long)af;
#ifdef USE_DEBUGGING
debug_printf(DEBUG_VERBOSE_STEP,"%7g & %7g = %7g\n", bf, af, (long)bf & (long)af);
#endif
}
break;
case OPCODE_INPLACE_LSHIFT:
case OPCODE_BINARY_LSHIFT:
{
new_tos->value = (long)bf << (long)af;
#ifdef USE_DEBUGGING
debug_printf(DEBUG_VERBOSE_STEP,"%7g << %7g = %7g\n", bf, af, (long)bf << (long)af);
#endif
}
break;
case OPCODE_INPLACE_RSHIFT:
case OPCODE_BINARY_RSHIFT:
{
new_tos->value = (long)bf >> (long)af;
#ifdef USE_DEBUGGING
debug_printf(DEBUG_VERBOSE_STEP,"%7g>> %7g = %7g\n", bf, af, (long)bf >> (long)af);
#endif
}
break;
case OPCODE_INPLACE_MODULO:
case OPCODE_BINARY_MODULO:
{
new_tos->value = (long)bf % (long)af;
#ifdef USE_DEBUGGING
debug_printf(DEBUG_VERBOSE_STEP,"%7g %% %7g = %7g\n", bf, af, (long)bf % (long)af);
#endif
}
break;
case OPCODE_INPLACE_FLOOR_DIVIDE:
case OPCODE_BINARY_FLOOR_DIVIDE:
{
new_tos->value = floor(bf / af);
#ifdef USE_DEBUGGING
debug_printf(DEBUG_VERBOSE_STEP,"%7g // %7g = %7g\n", bf, af, floor(bf / af));
#endif
}
break;
case OPCODE_INPLACE_TRUE_DIVIDE:
case OPCODE_BINARY_TRUE_DIVIDE:
{
new_tos->value = bf / af;
#ifdef USE_DEBUGGING
debug_printf(DEBUG_VERBOSE_STEP,"%7g / %7g = %7g\n", bf, af, bf / af);
#endif
}
break;
case OPCODE_INPLACE_SUBTRACT:
case OPCODE_BINARY_SUBTRACT:
{
new_tos->value = bf-af;
#ifdef USE_DEBUGGING
debug_printf(DEBUG_VERBOSE_STEP,"%7g - %7g = %7g\n", bf, af, bf - af);
#endif
}
break;
case OPCODE_INPLACE_POWER:
case OPCODE_BINARY_POWER:
{
new_tos->value = num_pow(bf, af); //TODO this will most likely not work correctly
#ifdef USE_DEBUGGING
debug_printf(DEBUG_VERBOSE_STEP,"%7g ** %7g = %7g\n", bf, af, num_pow(bf, af));
#endif
}
break;
case OPCODE_INPLACE_ADD:
case OPCODE_BINARY_ADD:
{
new_tos->value = bf + af;
#ifdef USE_DEBUGGING
debug_printf(DEBUG_VERBOSE_STEP,"%7g + %7g = %7g\n", bf, af, bf + af);
#endif
}
break;
}
}
int LogMessage(void *data, loglevels lev, logtypes type, const char *message, const char *func, int line, const char *file)
{
struct LogInfo *li=(struct LogInfo *)data;
char *msgcopy = NULL;
if (!data)
return 1;
/* Ensures that LOG_NONE level means nothing is logged. */
if (lev >= LEV_NONE) lev = LEV_DEBUG;
if (li) {
if (type == T_PRE)
type = li->deftype;
LogOption(data, "LEVEL", levnames[lev]);
if (((li->currlev >= lev) && (li->currtype & type)) ||
(li->currlev == LEV_DEBUG)) {
const char *format = li->format;
int mode = 0;
char *str = NULL;
char *holder = NULL;
signed int len = 0;
msgcopy = strdup(message);
holder = msgcopy;
if (!msgcopy)
return 0;
while (*holder != '\0') {
if (!isprint(*holder))
*holder = '.';
++holder;
}
while (*format) {
switch(*format) {
case '%':
if (mode == 1) {
str = StringAdd(str, "%", len);
mode=0;
}
else if (mode == 0) {
len = GetLen(&format);
mode = 1;
}
else
goto err;
break;
case 'm':
if (mode == 0)
str = StringAdd(str, "m", len);
else if (mode == 1) {
str = StringAdd(str, msgcopy, len);
mode = 0;
}
else
goto err;
break;
case 'd':
str = StringAdd(str, "%d", len);
break;
case 'p':
if (mode == 0)
str = StringAdd(str, "p", len);
else if (mode == 1) {
pid_t pid = getpid();
char val[(((sizeof(pid_t)*CHAR_BIT)/3)+2)];
sprintf(val,"%d",(int)pid);
str = StringAdd(str, val, len);
mode = 0;
}
else
goto err;
break;
case 's':
if (mode == 0)
str = StringAdd(str, "s", len);
else if (mode == 1) {
if (li->service)
str = StringAdd(str, li->service, len);
}
else
goto err;
break;
case 'f':
if (mode == 0)
str = StringAdd(str, "f", len);
else if (mode == 1) {
str = StringAdd(str, file, len);
}
else
goto err;
break;
case 'l':
if (mode == 0)
str = StringAdd(str, "l", len);
else if (mode == 1) {
char val[(((sizeof(pid_t)*CHAR_BIT)/3)+2)];
sprintf(val,"%d",line);
str = StringAdd(str, val, len);
}
else
goto err;
break;
case 'T':
if (mode == 0)
str = StringAdd(str, "N", len);
else if (mode == 1) {
int i = 0;
int k = 0x01;
while (!(type&k))
k <<= 1, i++;
str = StringAdd(str, typenames[i], len);
}
else
goto err;
break;
case 't':
if (mode == 0)
str = StringAdd(str, "n", len);
else if (mode == 1) {
char val[(((sizeof(pid_t)*CHAR_BIT)/3)+2)];
sprintf(val,"%d",type);
str = StringAdd(str, val, len);
}
else
goto err;
break;
case 'v':
if (mode == 0)
str = StringAdd(str, "v", len);
else if (mode == 1) {
char val[(((sizeof(pid_t)*CHAR_BIT)/3)+2)];
sprintf(val,"%d",lev);
str = StringAdd(str, val, len);
}
else
goto err;
break;
case 'V':
if (mode == 0)
str = StringAdd(str, "V", len);
else if (mode == 1) {
str = StringAdd(str, levnames[lev], len);
}
else
goto err;
break;
case 'F':
if (mode == 0)
str = StringAdd(str, "F", len);
else if (mode == 1) {
if (func)
str = StringAdd(str, func, len);
}
else
goto err;
break;
case 'h':
if (mode == 0)
str = StringAdd(str, "h", len);
else if (mode == 1) {
struct utsname u;
if (!uname(&u))
str = StringAdd(str, u.nodename, len);
else
goto err;
}
else
goto err;
break;
default:
{
char s[2];
s[0] = *format;
s[1] = '\0';
str = StringAdd(str, s, -1);
}
mode =0;
break;
}
format++;
}
str = StringAdd(str, "\n", -1);
LogOutput(data, str);
free(str);
}
}
free(msgcopy);
return 1;
err:
free(msgcopy);
return 0;
}
void Audio_Init()
{
StringAdd(1,AUDIO_TEMPLATE_ID,NODE_NAME,T("Audio template codec"));
StringAdd(1,AUDIO_TEMPLATE_ID,NODE_CONTENTTYPE,T("acodec/0x0055"));
NodeRegisterClass(&Template);
}
static void
DoReplace (FILE *f, ReplaceSet *s)
{
int c;
String *tag;
Replace *r;
SkipStack *ss = 0;
LoopStack *ls = 0;
int skipping = 0;
while ((c = getc (f)) != EOF)
{
if (c == '@')
{
tag = StringNew ();
while ((c = getc (f)) != '@')
{
if (c == EOF)
abort ();
StringAdd (tag, c);
}
if (ls)
StringAddString (tag, ls->extra->buf);
switch (tag->buf[0]) {
case '?':
ss = SkipStackPush (ss, skipping);
if (!ReplaceSetFind (s, tag->buf + 1))
skipping++;
LineSkip (f);
break;
case ':':
if (!ss)
abort ();
if (ss->skipping == skipping)
++skipping;
else
--skipping;
LineSkip (f);
break;
case ';':
skipping = ss->skipping;
ss = SkipStackPop (ss);
LineSkip (f);
break;
case '{':
ls = LoopStackPush (ls, f, tag->buf + 1);
LineSkip (f);
break;
case '}':
ls = LoopStackLoop (s, ls, f);
LineSkip (f);
break;
default:
r = ReplaceSetFind (s, tag->buf);
if (r && !skipping)
StringPut (stdout, r->text);
break;
}
StringDispose (tag);
}
else if (!skipping)
putchar (c);
}
}
static void
StringAddString (String *s, char *buf)
{
while (*buf)
StringAdd (s, *buf++);
}
