} else {
fprintf(stderr, "Unknown media type\n");
}
- fprintf(stderr, "\tVendor code \"%s\" - Version %d - revision %d\n", gf_4cc_to_str(udesc->vendor_code), udesc->version, udesc->revision);
+ if (udesc->vendor_code)
+ fprintf(stderr, "\tVendor code \"%s\" - Version %d - revision %d\n", gf_4cc_to_str(udesc->vendor_code), udesc->version, udesc->revision);
+
if (udesc->extension_buf) {
fprintf(stderr, "\tCodec configuration data size: %d bytes\n", udesc->extension_buf_size);
gf_free(udesc->extension_buf);
fprintf(stderr, "File has %d tracks\n", import.nb_tracks);
}
if (import.probe_duration) {
- fprintf(stderr, "Duration: %g ms\n", (Double) (import.probe_duration/1000.0));
+ fprintf(stderr, "Duration: %g s\n", (Double) (import.probe_duration/1000.0));
}
found = 0;
for (i=0; i<import.nb_tracks; i++) {
Bool force_cat, align_timelines, allow_add_in_command;
} CATEnum;
-Bool cat_enumerate(void *cbk, char *szName, char *szPath)
+Bool cat_enumerate(void *cbk, char *szName, char *szPath, GF_FileEnumInfo *file_info)
{
GF_Err e;
u32 len_rad1;
}
}
-static Bool wgt_enum_files(void *cbck, char *file_name, char *file_path)
+static Bool wgt_enum_files(void *cbck, char *file_name, char *file_path, GF_FileEnumInfo *file_info)
{
WGTEnum *wgt = (WGTEnum *)cbck;
gf_list_add(wgt->imports, gf_strdup(file_path) );
return 0;
}
-static Bool wgt_enum_dir(void *cbck, char *file_name, char *file_path)
+static Bool wgt_enum_dir(void *cbck, char *file_name, char *file_path, GF_FileEnumInfo *file_info)
{
if (!stricmp(file_name, "cvs") || !stricmp(file_name, ".svn")) return 0;
gf_enum_directory(file_path, 0, wgt_enum_files, cbck, NULL);
" only the xlink declared on the first rep of a period will be used\n"
" \":role=VALUE\" sets the role of this representation (cf DASH spec).\n"
" media with different roles belong to different adaptation sets.\n"
+ " \":desc_p=VALUE\" adds a descriptor at the Period level.\n"
+ " \":desc_as=VALUE\" adds a descriptor at the AdaptationSet level \n"
+ " two input files with different values will be in different AdaptationSet elements.\n"
+ " \":desc_as_c=VALUE\" adds a descriptor at the AdaptationSet level \n"
+ " value is ignored to created AdaptationSet elements.\n"
+ " \":desc_rep=VALUE\" adds a descriptor at the Representation level.\n"
+ " value is ignored to created AdaptationSet elements.\n"
"\n"
" -rap segments begin with random access points\n"
" Note: segment duration may not be exactly what asked by\n"
if (tsel_acts) gf_free(tsel_acts); \
if (brand_add) gf_free(brand_add); \
if (brand_rem) gf_free(brand_rem); \
- if (dash_inputs) gf_free(dash_inputs); \
+ if (dash_inputs) { \
+ u32 input_index; \
+ for (input_index = 0; input_index < dash_inputs->nb_rep_descs; input_index++) { \
+ gf_free(dash_inputs->rep_descs[input_index]); \
+ } \
+ gf_free(dash_inputs->rep_descs); \
+ for (input_index = 0; input_index < dash_inputs->nb_as_descs; input_index++) { \
+ gf_free(dash_inputs->as_descs[input_index]); \
+ } \
+ gf_free(dash_inputs->as_descs); \
+ for (input_index = 0; input_index < dash_inputs->nb_as_c_descs; input_index++) { \
+ gf_free(dash_inputs->as_c_descs[input_index]); \
+ } \
+ gf_free(dash_inputs->as_c_descs); \
+ for (input_index = 0; input_index < dash_inputs->nb_p_descs; input_index++) { \
+ gf_free(dash_inputs->p_descs[input_index]); \
+ } \
+ gf_free(dash_inputs->p_descs); \
+ gf_free(dash_inputs); \
+ } \
gf_sys_close(); \
return __ret_code; \
sep[0] = 0;
while (opts) {
sep = strchr(opts, ':');
+ while (sep) {
+ /* this is a real separator if it is followed by a keyword we are looking for */
+ if (!strnicmp(sep, ":id=", 4) ||
+ !strnicmp(sep, ":period=", 8) ||
+ !strnicmp(sep, ":bandwidth=", 11) ||
+ !strnicmp(sep, ":role=", 6) ||
+ !strnicmp(sep, ":desc", 5) ||
+ !strnicmp(sep, ":xlink=", 7)) {
+ break;
+ } else {
+ sep = strchr(sep+1, ':');
+ }
+ }
if (sep && !strncmp(sep, "://", 3)) sep = strchr(sep+3, ':');
if (sep) sep[0] = 0;
}
else if (!strnicmp(opts, "bandwidth=", 10)) di->bandwidth = atoi(opts+10);
else if (!strnicmp(opts, "role=", 5)) strncpy(di->role, opts+5, 99);
+ else if (!strnicmp(opts, "desc", 4)) {
+ u32 *nb_descs;
+ char ***descs;
+ u32 opt_offset;
+ u32 len;
+ if (!strnicmp(opts, "desc_p=", 7)) {
+ nb_descs = &di->nb_p_descs;
+ descs = &di->p_descs;
+ opt_offset = 7;
+ } else if (!strnicmp(opts, "desc_as=", 8)) {
+ nb_descs = &di->nb_as_descs;
+ descs = &di->as_descs;
+ opt_offset = 8;
+ } else if (!strnicmp(opts, "desc_as_c=", 8)) {
+ nb_descs = &di->nb_as_c_descs;
+ descs = &di->as_c_descs;
+ opt_offset = 10;
+ } else if (!strnicmp(opts, "desc_rep=", 8)) {
+ nb_descs = &di->nb_rep_descs;
+ descs = &di->rep_descs;
+ opt_offset = 9;
+ }
+ (*nb_descs)++;
+ opts += opt_offset;
+ len = (u32) strlen(opts);
+ (*descs) = (char **)gf_realloc((*descs), (*nb_descs)*sizeof(char *));
+ (*descs)[(*nb_descs)-1] = (char *)gf_malloc((len+1)*sizeof(char));
+ strncpy((*descs)[(*nb_descs)-1], opts, len);
+ (*descs)[(*nb_descs)-1][len] = 0;
+ }
else if (!strnicmp(opts, "xlink=", 6)) {
if (strlen(opts+6) > 199) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("[DASH] XLink cannot exceed 99 characters in MP4Box, truncating ...\n"));
static char pl_path[GF_MAX_PATH];
static Bool no_mime_check = GF_TRUE;
static Bool be_quiet = GF_FALSE;
-static u32 log_time_start = 0;
+static u64 log_time_start = 0;
static Bool log_utc_time = GF_FALSE;
static Bool loop_at_end = GF_FALSE;
static u32 forced_width=0;
"\t \"mutex\" : mutex\n"
"\t \"all\" : all tools logged - other tools can be specified afterwards.\n"
"\n"
- "\t-log-clock or -lc : logs time in ms since start time of GPAC before each log line.\n"
+ "\t-log-clock or -lc : logs time in micro sec since start time of GPAC before each log line.\n"
"\t-log-utc or -lu : logs UTC time in ms before each log line.\n"
"\t-ifce IPIFCE : Sets default Multicast interface\n"
"\t-size WxH: specifies visual size (default: scene size)\n"
ResetCaption();
break;
- case GF_EVENT_OPENFILE:
+ case GF_EVENT_DROPFILE:
{
u32 i, pos;
/*todo - force playlist mode*/
vsprintf(szMsg, fmt, list);
UpdateRTInfo(szMsg + 6 /*"[RTI] "*/);
} else {
- if (log_time_start) fprintf(logs, "[At %d]", gf_sys_clock() - log_time_start);
+ if (log_time_start) fprintf(logs, "[At "LLD"]", gf_sys_clock_high_res() - log_time_start);
if (log_utc_time) {
u64 utc_clock = gf_net_get_utc() ;
time_t secs = utc_clock/1000;
GF_LOG(GF_LOG_DEBUG, GF_LOG_RTI, ("[RTI] System state when enabling log\n"));
} else if (log_time_start) {
- log_time_start = gf_sys_clock();
+ log_time_start = gf_sys_clock_high_res();
}
}
}
GLint pixel_format=GL_LUMINANCE;\r
GLint texture_type=GL_TEXTURE_RECTANGLE_EXT;\r
u32 gl_nb_frames = 1;\r
-u32 gl_upload_time = 0;\r
-u32 gl_draw_time = 0;\r
+u64 gl_upload_time = 0;\r
+u64 gl_draw_time = 0;\r
Bool pbo_mode = GF_TRUE;\r
Bool first_tx_load = GF_FALSE;\r
Bool use_vsync=0;\r
void sdl_draw_frame(u8 *pY, u8 *pU, u8 *pV, u32 w, u32 h, u32 bit_depth, u32 stride)\r
{\r
u32 needs_stride = 0;\r
- u32 now, end;\r
+ u64 now, end;\r
\r
if (stride != w) {\r
if (bit_depth==10) {\r
if (stride != 2*w) {\r
- needs_stride = stride;\r
+ needs_stride = stride / 2;\r
}\r
} else {\r
needs_stride = stride;\r
\r
glEnable(texture_type);\r
\r
- now = gf_sys_clock();\r
+ now = gf_sys_clock_high_res();\r
\r
\r
if (first_tx_load) {\r
#elif (COPY_TYPE==4)\r
#else\r
linesize = width*Bpp;\r
- p_stride = stride*Bpp;\r
+ p_stride = stride;\r
count = h;\r
#if (COPY_TYPE==2)\r
c2 = linesize/4;\r
#elif (COPY_TYPE==4)\r
#else\r
linesize = width*Bpp/2;\r
- p_stride = stride*Bpp/2;\r
+ p_stride = stride/2;\r
count/=2;\r
#if (COPY_TYPE==2)\r
c2 /= 2;\r
\r
if (needs_stride) glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);\r
}\r
- end = gf_sys_clock() - now;\r
+ end = gf_sys_clock_high_res() - now;\r
\r
if (!first_tx_load) {\r
gl_nb_frames ++;\r
\r
SDL_GL_SwapWindow(window);\r
\r
- gl_draw_time += gf_sys_clock() - now;\r
+ gl_draw_time += gf_sys_clock_high_res() - now;\r
return;\r
}\r
\r
{\r
Double rate;\r
u32 i, count;\r
- u32 start = gf_sys_clock();\r
+ u64 start = gf_sys_clock_high_res();\r
\r
count = 600;\r
for (i=0; i<count; i++) {\r
- sdl_draw_frame(pY, pU, pV, width, height, 8, width);\r
+ sdl_draw_frame(pY, pU, pV, width, height, bpp, width);\r
}\r
\r
- start = gf_sys_clock() - start;\r
+ start = gf_sys_clock_high_res() - start;\r
rate = 3*size/2;\r
- rate *= count;\r
+ rate *= count*1000;\r
rate /= start; //in ms\r
rate /= 1000; //==*1000 (in s) / 1000 * 1000 in MB /s\r
- fprintf(stdout, "gltext pushed %d frames in %d ms - FPS %g - data rate %g MB/s\n", count, start, 1000.0*count/start, rate);\r
+ fprintf(stdout, "gltext pushed %d frames in %d ms - FPS %g - data rate %g MB/s\n", count, start/1000, 1000000.0*count/start, rate);\r
}\r
\r
void PrintUsage()\r
);\r
}\r
\r
+\r
+\r
int main(int argc, char **argv)\r
{\r
Bool sdl_bench_yuv = GF_FALSE;\r
Bool no_display = GF_FALSE;\r
- u32 start, now, check_prompt;\r
+ u64 start, now;\r
+ u32 check_prompt;\r
Bool sdl_is_init=GF_FALSE, run;\r
Bool paused = GF_FALSE;\r
- u32 pause_time = 0;\r
+ u64 pause_time = 0;\r
GF_ISOFile *isom;\r
u32 i, count, track = 0;\r
u32 nb_frames_at_start = 0;\r
continue;\r
}\r
if (!strcmp(arg, "-bench-yuv")) sdl_bench_yuv=1;\r
+ else if (!strcmp(arg, "-bench-yuv10")) sdl_bench_yuv=2;\r
else if (!strcmp(arg, "-sys-mem")) use_raw_memory = 0;\r
else if (!strcmp(arg, "-vsync")) use_vsync = 1;\r
else if (!strcmp(arg, "-use-pbo")) use_pbo = 1;\r
gf_log_set_tool_level(GF_LOG_ALL, GF_LOG_WARNING);\r
\r
if (sdl_bench_yuv) {\r
- sdl_init(3840, 2160, 8, 3840, use_pbo);\r
+ sdl_init(3840, 2160, (sdl_bench_yuv==2) ? 10 : 8, 3840, use_pbo);\r
sdl_bench();\r
sdl_close();\r
gf_sys_close();\r
}\r
\r
count = gf_isom_get_sample_count(isom, track);\r
- start = gf_sys_clock();\r
+ start = gf_sys_clock_high_res();\r
\r
esd = gf_isom_get_esd(isom, track, 1);\r
ohevc = libOpenHevcInit(nb_threads, mode);\r
if (esd->decoderConfig && esd->decoderConfig->decoderSpecificInfo && esd->decoderConfig->decoderSpecificInfo->data) {\r
libOpenHevcCopyExtraData(ohevc, esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength+8);\r
}\r
+\r
+ libOpenHevcSetActiveDecoders(ohevc, 1);\r
+ libOpenHevcSetViewLayers(ohevc, 1);\r
+\r
libOpenHevcStartDecoder(ohevc);\r
gf_odf_desc_del((GF_Descriptor *)esd);\r
gf_isom_set_sample_padding(isom, track, 8);\r
GF_ISOSample *sample = gf_isom_get_sample(isom, track, i+1, &di);\r
\r
if ( libOpenHevcDecode(ohevc, sample->data, sample->dataLength, sample->DTS+sample->CTS_Offset) ) {\r
- OpenHevc_Frame_cpy HVCFrame;\r
-\r
- libOpenHevcGetPictureInfo(ohevc, &HVCFrame.frameInfo);\r
- if (!sdl_is_init && !no_display) {\r
- sdl_init(HVCFrame.frameInfo.nWidth, HVCFrame.frameInfo.nHeight, HVCFrame.frameInfo.nBitDepth, HVCFrame.frameInfo.nYPitch+32, use_pbo);\r
- sdl_is_init=1;\r
- start = gf_sys_clock();\r
- nb_frames_at_start = i+1;\r
- }\r
-\r
if (no_display) {\r
OpenHevc_Frame HVCFrame_ptr;\r
libOpenHevcGetOutput(ohevc, 1, &HVCFrame_ptr);\r
OpenHevc_Frame HVCFrame_ptr;\r
libOpenHevcGetOutput(ohevc, 1, &HVCFrame_ptr);\r
\r
- sdl_draw_frame((u8 *) HVCFrame_ptr.pvY, (u8 *) HVCFrame_ptr.pvU, (u8 *) HVCFrame_ptr.pvV, HVCFrame.frameInfo.nWidth, HVCFrame.frameInfo.nHeight, HVCFrame.frameInfo.nBitDepth, HVCFrame.frameInfo.nYPitch+32);\r
+\r
+ if (!sdl_is_init && !no_display) {\r
+ sdl_init(HVCFrame_ptr.frameInfo.nWidth, HVCFrame_ptr.frameInfo.nHeight, HVCFrame_ptr.frameInfo.nBitDepth, HVCFrame_ptr.frameInfo.nYPitch, use_pbo);\r
+ sdl_is_init=1;\r
+ start = gf_sys_clock_high_res();\r
+ nb_frames_at_start = i+1;\r
+ }\r
+\r
+ sdl_draw_frame((u8 *) HVCFrame_ptr.pvY, (u8 *) HVCFrame_ptr.pvU, (u8 *) HVCFrame_ptr.pvV, HVCFrame_ptr.frameInfo.nWidth, HVCFrame_ptr.frameInfo.nHeight, HVCFrame_ptr.frameInfo.nBitDepth, HVCFrame_ptr.frameInfo.nYPitch);\r
} else {\r
- memset(&HVCFrame, 0, sizeof(OpenHevc_Frame) );\r
+ OpenHevc_Frame_cpy HVCFrame;\r
+ memset(&HVCFrame, 0, sizeof(OpenHevc_Frame_cpy) );\r
+\r
+ libOpenHevcGetPictureInfoCpy(ohevc, &HVCFrame.frameInfo);\r
+\r
+ if (!sdl_is_init && !no_display) {\r
+ sdl_init(HVCFrame.frameInfo.nWidth, HVCFrame.frameInfo.nHeight, HVCFrame.frameInfo.nBitDepth, HVCFrame.frameInfo.nYPitch, use_pbo);\r
+ sdl_is_init=1;\r
+ start = gf_sys_clock_high_res();\r
+ nb_frames_at_start = i+1;\r
+ }\r
+\r
HVCFrame.pvY = (void*) pY;\r
HVCFrame.pvU = (void*) pU;\r
HVCFrame.pvV = (void*) pV;\r
+\r
libOpenHevcGetOutputCpy(ohevc, 1, &HVCFrame);\r
+\r
sdl_draw_frame(pY, pU, pV, HVCFrame.frameInfo.nWidth, HVCFrame.frameInfo.nHeight, HVCFrame.frameInfo.nBitDepth, HVCFrame.frameInfo.nYPitch);\r
}\r
}\r
\r
gf_isom_sample_del(&sample);\r
\r
- now = gf_sys_clock();\r
- fprintf(stderr, "%d %% %d frames in %d ms - FPS %02.2g - push time %d ms - draw %d ms\r", 100*(i+1-nb_frames_at_start)/count, i+1-nb_frames_at_start, now-start, 1000.0 * (i+1-nb_frames_at_start) / (now-start), gl_upload_time / gl_nb_frames , (gl_draw_time - gl_upload_time) / gl_nb_frames );\r
+ now = gf_sys_clock_high_res();\r
+ fprintf(stderr, "%d %% %d frames in %d ms - FPS %03.2f - push time "LLD" ms - draw "LLD" ms\r", 100*(i+1-nb_frames_at_start)/count, i+1-nb_frames_at_start, (now-start)/1000, 1000000.0 * (i+1-nb_frames_at_start) / (now-start), gl_upload_time / gl_nb_frames/1000 , (gl_draw_time - gl_upload_time) / gl_nb_frames/1000 );\r
} else {\r
gf_sleep(10);\r
i--;\r
case 'p':\r
if (paused) {\r
paused=0;\r
- start += gf_sys_clock()-pause_time;\r
+ start += gf_sys_clock_high_res()-pause_time;\r
} else {\r
paused = 1;\r
- pause_time=gf_sys_clock();\r
+ pause_time=gf_sys_clock_high_res();\r
}\r
break;\r
case 'r':\r
- start = gf_sys_clock();\r
+ start = gf_sys_clock_high_res();\r
nb_frames_at_start = i+1;\r
gl_upload_time = gl_draw_time = 0;\r
gl_nb_frames=1;\r
check_prompt=0;\r
}\r
}\r
- now = gf_sys_clock();\r
- fprintf(stderr, "Decoded %d frames in %d ms - FPS %g\n", i+1, now-start, 1000.0 * (i+1) / (now-start) );\r
+ now = gf_sys_clock_high_res();\r
+ fprintf(stderr, "\nDecoded %d frames in %d ms - FPS %g\n", i+1, (now-start)/1000, 1000000.0 * (i+1) / (now-start) );\r
\r
libOpenHevcClose(ohevc);\r
gf_isom_close(isom);\r
fflush(lc->out);
}
-Bool loadcompare_one(void *cbck, char *item_name, char *item_path)
+Bool loadcompare_one(void *cbck, char *item_name, char *item_path, GF_FileEnumInfo *file_info)
{
GF_Err e;
GF_LoadCompare *lc = cbck;
GF_SceneDumper *dump;
char *tmp;
- gf_sys_init();
+ gf_sys_init(0);
GF_SAFEALLOC(converter, SVG2BIFS_Converter);
fprintf(stdout, "Dumping BIFS scenegraph\n");
tmp = strchr(argv[1], '.');
tmp[0] = 0;
- dump = gf_sm_dumper_new(converter->bifs_sg, argv[1], ' ', GF_SM_DUMP_XMTA);
+ dump = gf_sm_dumper_new(converter->bifs_sg, argv[1], ' ', GF_SM_DUMP_BT);
tmp[0] = '.';
gf_sm_dump_graph(dump, 1, 0);
}
return false;
- case GF_EVENT_OPENFILE:
+ case GF_EVENT_DROPFILE:
var files = evt.files;
/*todo - handle playlist*/
if (files.length) {
*\param src_wnd source rectangle. If null the entire source surface is used
*\return error code if any
*/
-GF_Err gf_color_write_yv12_10_to_yuv(GF_VideoSurface *vs_dst, unsigned char *pY, unsigned char *pU, unsigned char*pV, u32 src_stride, u32 src_width, u32 src_height, const GF_Window *src_wnd);
+GF_Err gf_color_write_yv12_10_to_yuv(GF_VideoSurface *vs_dst, unsigned char *pY, unsigned char *pU, unsigned char*pV, u32 src_stride, u32 src_width, u32 src_height, const GF_Window *src_wnd, Bool swap_uv);
/*! @} */
typedef struct {
- /* GF_EVENT_OPENFILE*/
+ /* GF_EVENT_DROPFILE*/
u8 type;
u32 nb_files;
char **files;
GF_EVENT_MIGRATE, /*indicates a session migration request*/
GF_EVENT_DISCONNECT, /*indicates the current url should be disconnected*/
GF_EVENT_RESOLUTION, /*indicates the screen resolution has changed*/
- GF_EVENT_OPENFILE,
+ GF_EVENT_DROPFILE,
/* Events for Keyboad */
GF_EVENT_TEXT_EDITING_START,
GF_EVENT_TEXT_EDITING_END,
GF_List *time_nodes;
/*all textures (texture handlers)*/
GF_List *textures;
+ Bool texture_inserted;
/*all textures to be destroyed (needed for openGL context ...)*/
GF_List *textures_gc;
/*parent group for composition: can be Form, Layout or Layer2D*/
struct _parent_node_2d *parent;
+ /*override appearance of all nodes with this one*/
+ GF_Node *override_appearance;
+
/*group/object bounds in local coordinate system*/
GF_Rect bounds;
#ifndef GPAC_DISABLE_3D
void compositor_2d_reset_gl_auto(GF_Compositor *compositor);
void compositor_2d_hybgl_flush_video(GF_Compositor *compositor, GF_IRect *area);
-void compositor_2d_hybgl_clear_surface_ex(GF_VisualManager *visual, GF_IRect *rc, u32 BackColor, Bool is_offscreen_clear);
+void compositor_2d_hybgl_clear_surface(GF_VisualManager *visual, GF_IRect *rc, u32 BackColor, Bool is_offscreen_clear);
#endif
Bool compositor_texture_rectangles(GF_VisualManager *visual, GF_TextureHandler *txh, GF_IRect *clip, GF_Rect *unclip, GF_Window *src, GF_Window *dst, Bool *disable_blit, Bool *has_scale);
struct JSObject *document;
Bool dcci_doc;
+
+ Bool trigger_gc;
#endif
};
{
GF_SG_PROTO_LOADED = 1,
GF_SG_PROTO_IS_GROUPING = 2,
+ GF_SG_PROTO_HARDCODED = 4,
};
typedef struct _proto_instance
char periodID[100];
char xlink[100];
char role[100];
+ u32 nb_rep_descs;
+ char **rep_descs;
+ u32 nb_p_descs;
+ char **p_descs;
+ u32 nb_as_descs;
+ char **as_descs;
+ u32 nb_as_c_descs;
+ char **as_c_descs;
u32 bandwidth;
} GF_DashSegmenterInput;
/*HTML Media Source events*/
GF_DOM_EVENT_MEDIASOURCE = 1<<11,
+ /*Internal GPAC events*/
+ GF_DOM_EVENT_GPAC = 1<<30,
/*fake events - these events are NEVER fired*/
GF_DOM_EVENT_FAKE = 1<<31,
} GF_DOMEventCategory;
*/
void gf_get_user_name(char *buf, u32 buf_size);
+
+/*!\brief FileEnum info object
+ *
+ *The FileEnumInfo object is used to get file attributes upon enumeration of a directory.
+*/
+typedef struct
+{
+ /*!File is marked as hidden*/
+ Bool hidden;
+ /*!File is a directory*/
+ Bool directory;
+ /*!File is a drive mountpoint*/
+ Bool drive;
+ /*!File is a system file*/
+ Bool system;
+ /*!File size in bytes*/
+ u64 size;
+ /*!File last modif time in UTC seconds*/
+ u64 last_modified;
+} GF_FileEnumInfo;
+
/*!
* \brief Directory Enumeration Callback
*
* \param cbck Opaque user data.
* \param item_name File or directory name.
* \param item_path File or directory full path and name from filesystem root.
+ * \param file_info information for the file or directory.
* \return 1 to abort enumeration, 0 to continue enumeration.
*
*/
-typedef Bool (*gf_enum_dir_item)(void *cbck, char *item_name, char *item_path);
+typedef Bool (*gf_enum_dir_item)(void *cbck, char *item_name, char *item_path, GF_FileEnumInfo *file_info);
/*!
* \brief Directory enumeration
*
*/
u32 gf_crc_32(const char *data, u32 size);
-#ifdef _WIN32_WCE
+#ifdef WIN32
/*!
* \brief WINCE time constant
* \hideinitializer
*/
#define GPAC_VERSION "0.5.1-DEV"
#define GPAC_VERSION_MAJOR 3
-#define GPAC_VERSION_MINOR 0
+#define GPAC_VERSION_MINOR 1
#define GPAC_VERSION_MICRO 0
#include <gpac/revision.h>
} else if (get_yuv_base(src_s->pixel_format)==GF_PIXEL_YV12_10) {
if (format_is_yuv(dst_s->pixel_format)) {
/*generic YV planar to YUV (planar or not) */
- gf_color_write_yv12_10_to_yuv(dst_s, src_s->video_buffer, src_s->u_ptr, src_s->v_ptr, src_s->pitch_y, src_s->width, src_s->height, src_wnd);
+ gf_color_write_yv12_10_to_yuv(dst_s, src_s->video_buffer, src_s->u_ptr, src_s->v_ptr, src_s->pitch_y, src_s->width, src_s->height, src_wnd, 1);
return;
}
} else if (format_is_yuv(src_s->pixel_format)) {
u32 i;
HDROP hDrop = (HDROP) wParam;
- evt.type = GF_EVENT_OPENFILE;
+ evt.type = GF_EVENT_DROPFILE;
evt.open_file.nb_files = DragQueryFile(hDrop, 0xFFFFFFFF, NULL, 0);
evt.open_file.files = gf_malloc(sizeof(char *)*evt.open_file.nb_files);
for (i=0; i<evt.open_file.nb_files; i++) {
dst.video_buffer = ffd->direct_output ? ffd->conv_buffer : outBuffer;
dst.pixel_format = GF_PIXEL_YV12;
- gf_color_write_yv12_10_to_yuv(&dst, (u8 *) frame->data[0], frame->data[1], frame->data[2], frame->linesize[0], ctx->width, ctx->height, NULL);
+ gf_color_write_yv12_10_to_yuv(&dst, (u8 *) frame->data[0], frame->data[1], frame->data[2], frame->linesize[0], ctx->width, ctx->height, NULL, 0);
*outBufferLength = ffd->out_size;
return GF_OK;
}
}
}
-static Bool ft_enum_fonts(void *cbck, char *file_name, char *file_path)
+static Bool ft_enum_fonts(void *cbck, char *file_name, char *file_path, GF_FileEnumInfo *file_info)
{
char *szfont;
FT_Face face;
return 0;
}
-static Bool ft_enum_fonts_dir(void *cbck, char *file_name, char *file_path)
+static Bool ft_enum_fonts_dir(void *cbck, char *file_name, char *file_path, GF_FileEnumInfo *file_info)
{
GF_LOG(GF_LOG_DEBUG, GF_LOG_PARSER, ("[FreeType] Scanning directory %s (%s)\n", file_name, file_path));
gf_enum_directory(file_path, 0, ft_enum_fonts, cbck, "ttf;ttc");
static SMJS_FUNC_PROP_GET( gpac_getProperty)
-const char *res;
-char *prop_name;
-GF_Terminal *term = gpac_get_term(c, obj);
-if (!term) return JS_FALSE;
-
-if (!SMJS_ID_IS_STRING(id)) return JS_TRUE;
-prop_name = SMJS_CHARS_FROM_STRING(c, SMJS_ID_TO_STRING(id));
-if (!prop_name) return JS_FALSE;
-
-if (!strcmp(prop_name, "last_working_directory")) {
- res = gf_cfg_get_key(term->user->config, "General", "LastWorkingDir");
- if (!res) res = gf_cfg_get_key(term->user->config, "General", "ModulesDirectory");
- *vp = STRING_TO_JSVAL(JS_NewStringCopyZ(c, res));
-}
-else if (!strcmp(prop_name, "scale_x")) {
- *vp = DOUBLE_TO_JSVAL( JS_NewDouble(c, FIX2FLT(term->compositor->scale_x)) );
-}
-else if (!strcmp(prop_name, "scale_y")) {
- *vp = DOUBLE_TO_JSVAL( JS_NewDouble(c, FIX2FLT(term->compositor->scale_y)) );
-}
-else if (!strcmp(prop_name, "translation_x")) {
- *vp = DOUBLE_TO_JSVAL( JS_NewDouble(c, FIX2FLT(term->compositor->trans_x)) );
-}
-else if (!strcmp(prop_name, "translation_y")) {
- *vp = DOUBLE_TO_JSVAL( JS_NewDouble(c, FIX2FLT(term->compositor->trans_y)) );
-}
-else if (!strcmp(prop_name, "rectangular_textures")) {
- Bool any_size = GF_FALSE;
-#ifndef GPAC_DISABLE_3D
- if (term->compositor->gl_caps.npot_texture || term->compositor->gl_caps.rect_texture)
- any_size = GF_TRUE;
-#endif
- *vp = BOOLEAN_TO_JSVAL( any_size ? JS_TRUE : JS_FALSE );
-}
-else if (!strcmp(prop_name, "batteryOn")) {
- Bool on_battery = GF_FALSE;
- gf_sys_get_battery_state(&on_battery, NULL, NULL, NULL, NULL);
- *vp = BOOLEAN_TO_JSVAL( on_battery ? JS_TRUE : JS_FALSE );
-}
-else if (!strcmp(prop_name, "batteryCharging")) {
- u32 on_charge = 0;
- gf_sys_get_battery_state(NULL, &on_charge, NULL, NULL, NULL);
- *vp = BOOLEAN_TO_JSVAL( on_charge ? JS_TRUE : JS_FALSE );
-}
-else if (!strcmp(prop_name, "batteryPercent")) {
- u32 level = 0;
- gf_sys_get_battery_state(NULL, NULL, &level, NULL, NULL);
- *vp = INT_TO_JSVAL( level );
-}
-else if (!strcmp(prop_name, "batteryLifeTime")) {
- u32 level = 0;
- gf_sys_get_battery_state(NULL, NULL, NULL, &level, NULL);
- *vp = INT_TO_JSVAL( level );
-}
-else if (!strcmp(prop_name, "batteryFullLifeTime")) {
- u32 level = 0;
- gf_sys_get_battery_state(NULL, NULL, NULL, NULL, &level);
- *vp = INT_TO_JSVAL( level );
-}
-else if (!strcmp(prop_name, "hostname")) {
- char hostname[100];
- gf_sk_get_host_name((char*)hostname);
- *vp = STRING_TO_JSVAL(JS_NewStringCopyZ(c, hostname));
-}
-else if (!strcmp(prop_name, "fullscreen")) {
- *vp = BOOLEAN_TO_JSVAL( term->compositor->fullscreen ? JS_TRUE : JS_FALSE);
-}
-else if (!strcmp(prop_name, "current_path")) {
- char *url = gf_url_concatenate(term->root_scene->root_od->net_service->url, "");
- if (!url) url = gf_strdup("");
- *vp = STRING_TO_JSVAL(JS_NewStringCopyZ(c, url));
- gf_free(url);
-}
-else if (!strcmp(prop_name, "volume")) {
- *vp = INT_TO_JSVAL( gf_term_get_option(term, GF_OPT_AUDIO_VOLUME));
-}
-else if (!strcmp(prop_name, "navigation")) {
- *vp = INT_TO_JSVAL( gf_term_get_option(term, GF_OPT_NAVIGATION));
-}
-else if (!strcmp(prop_name, "navigation_type")) {
- *vp = INT_TO_JSVAL( gf_term_get_option(term, GF_OPT_NAVIGATION_TYPE) );
-}
-else if (!strcmp(prop_name, "hardware_yuv")) {
- *vp = INT_TO_JSVAL( (term->compositor->video_out->hw_caps & GF_VIDEO_HW_HAS_YUV) ? 1 : 0 );
-}
-else if (!strcmp(prop_name, "hardware_rgb")) {
- *vp = INT_TO_JSVAL( (term->compositor->video_out->hw_caps & GF_VIDEO_HW_HAS_RGB) ? 1 : 0 );
-}
-else if (!strcmp(prop_name, "hardware_rgba")) {
- u32 has_rgba = (term->compositor->video_out->hw_caps & GF_VIDEO_HW_HAS_RGBA) ? 1 : 0;
-#ifndef GPAC_DISABLE_3D
- if (term->compositor->hybrid_opengl || term->compositor->is_opengl) has_rgba = 1;
-#endif
- *vp = INT_TO_JSVAL( has_rgba );
-}
-else if (!strcmp(prop_name, "hardware_stretch")) {
- *vp = INT_TO_JSVAL( (term->compositor->video_out->hw_caps & GF_VIDEO_HW_HAS_STRETCH) ? 1 : 0 );
-}
-else if (!strcmp(prop_name, "screen_width")) {
- *vp = INT_TO_JSVAL( term->compositor->video_out->max_screen_width);
-}
-else if (!strcmp(prop_name, "screen_height")) {
- *vp = INT_TO_JSVAL( term->compositor->video_out->max_screen_height);
-}
-else if (!strcmp(prop_name, "http_bitrate")) {
- *vp = INT_TO_JSVAL( gf_dm_get_data_rate(term->downloader)*8/1024);
-}
-else if (!strcmp(prop_name, "fps")) {
- Double fps = gf_sc_get_fps(term->compositor, 0);
- *vp = DOUBLE_TO_JSVAL(JS_NewDouble(c, fps) );
-}
-else if (!strcmp(prop_name, "cpu_load")) {
- GF_GPACJSExt *ext = (GF_GPACJSExt *)SMJS_GET_PRIVATE(c, obj);
- gf_sys_get_rti(ext->rti_refresh_rate, &ext->rti, 0);
- *vp = INT_TO_JSVAL(ext->rti.process_cpu_usage);
-}
-else if (!strcmp(prop_name, "memory")) {
- GF_GPACJSExt *ext = (GF_GPACJSExt *)SMJS_GET_PRIVATE(c, obj);
- gf_sys_get_rti(ext->rti_refresh_rate, &ext->rti, 0);
- *vp = INT_TO_JSVAL(ext->rti.process_memory);
-}
+ const char *res;
+ char *prop_name;
+ GF_Terminal *term = gpac_get_term(c, obj);
+ if (!term) return JS_FALSE;
+
+ if (!SMJS_ID_IS_STRING(id)) return JS_TRUE;
+ prop_name = SMJS_CHARS_FROM_STRING(c, SMJS_ID_TO_STRING(id));
+ if (!prop_name) return JS_FALSE;
+ if (!strcmp(prop_name, "last_working_directory")) {
+ res = gf_cfg_get_key(term->user->config, "General", "LastWorkingDir");
+ if (!res) res = gf_cfg_get_key(term->user->config, "General", "ModulesDirectory");
+ *vp = STRING_TO_JSVAL(JS_NewStringCopyZ(c, res));
+ }
+ else if (!strcmp(prop_name, "scale_x")) {
+ *vp = DOUBLE_TO_JSVAL( JS_NewDouble(c, FIX2FLT(term->compositor->scale_x)) );
+ }
+ else if (!strcmp(prop_name, "scale_y")) {
+ *vp = DOUBLE_TO_JSVAL( JS_NewDouble(c, FIX2FLT(term->compositor->scale_y)) );
+ }
+ else if (!strcmp(prop_name, "translation_x")) {
+ *vp = DOUBLE_TO_JSVAL( JS_NewDouble(c, FIX2FLT(term->compositor->trans_x)) );
+ }
+ else if (!strcmp(prop_name, "translation_y")) {
+ *vp = DOUBLE_TO_JSVAL( JS_NewDouble(c, FIX2FLT(term->compositor->trans_y)) );
+ }
+ else if (!strcmp(prop_name, "rectangular_textures")) {
+ Bool any_size = GF_FALSE;
+ #ifndef GPAC_DISABLE_3D
+ if (term->compositor->gl_caps.npot_texture || term->compositor->gl_caps.rect_texture)
+ any_size = GF_TRUE;
+ #endif
+ *vp = BOOLEAN_TO_JSVAL( any_size ? JS_TRUE : JS_FALSE );
+ }
+ else if (!strcmp(prop_name, "batteryOn")) {
+ Bool on_battery = GF_FALSE;
+ gf_sys_get_battery_state(&on_battery, NULL, NULL, NULL, NULL);
+ *vp = BOOLEAN_TO_JSVAL( on_battery ? JS_TRUE : JS_FALSE );
+ }
+ else if (!strcmp(prop_name, "batteryCharging")) {
+ u32 on_charge = 0;
+ gf_sys_get_battery_state(NULL, &on_charge, NULL, NULL, NULL);
+ *vp = BOOLEAN_TO_JSVAL( on_charge ? JS_TRUE : JS_FALSE );
+ }
+ else if (!strcmp(prop_name, "batteryPercent")) {
+ u32 level = 0;
+ gf_sys_get_battery_state(NULL, NULL, &level, NULL, NULL);
+ *vp = INT_TO_JSVAL( level );
+ }
+ else if (!strcmp(prop_name, "batteryLifeTime")) {
+ u32 level = 0;
+ gf_sys_get_battery_state(NULL, NULL, NULL, &level, NULL);
+ *vp = INT_TO_JSVAL( level );
+ }
+ else if (!strcmp(prop_name, "batteryFullLifeTime")) {
+ u32 level = 0;
+ gf_sys_get_battery_state(NULL, NULL, NULL, NULL, &level);
+ *vp = INT_TO_JSVAL( level );
+ }
+ else if (!strcmp(prop_name, "hostname")) {
+ char hostname[100];
+ gf_sk_get_host_name((char*)hostname);
+ *vp = STRING_TO_JSVAL(JS_NewStringCopyZ(c, hostname));
+ }
+ else if (!strcmp(prop_name, "fullscreen")) {
+ *vp = BOOLEAN_TO_JSVAL( term->compositor->fullscreen ? JS_TRUE : JS_FALSE);
+ }
+ else if (!strcmp(prop_name, "current_path")) {
+ char *url = gf_url_concatenate(term->root_scene->root_od->net_service->url, "");
+ if (!url) url = gf_strdup("");
+ *vp = STRING_TO_JSVAL(JS_NewStringCopyZ(c, url));
+ gf_free(url);
+ }
+ else if (!strcmp(prop_name, "volume")) {
+ *vp = INT_TO_JSVAL( gf_term_get_option(term, GF_OPT_AUDIO_VOLUME));
+ }
+ else if (!strcmp(prop_name, "navigation")) {
+ *vp = INT_TO_JSVAL( gf_term_get_option(term, GF_OPT_NAVIGATION));
+ }
+ else if (!strcmp(prop_name, "navigation_type")) {
+ *vp = INT_TO_JSVAL( gf_term_get_option(term, GF_OPT_NAVIGATION_TYPE) );
+ }
+ else if (!strcmp(prop_name, "hardware_yuv")) {
+ *vp = INT_TO_JSVAL( (term->compositor->video_out->hw_caps & GF_VIDEO_HW_HAS_YUV) ? 1 : 0 );
+ }
+ else if (!strcmp(prop_name, "hardware_rgb")) {
+ *vp = INT_TO_JSVAL( (term->compositor->video_out->hw_caps & GF_VIDEO_HW_HAS_RGB) ? 1 : 0 );
+ }
+ else if (!strcmp(prop_name, "hardware_rgba")) {
+ u32 has_rgba = (term->compositor->video_out->hw_caps & GF_VIDEO_HW_HAS_RGBA) ? 1 : 0;
+ #ifndef GPAC_DISABLE_3D
+ if (term->compositor->hybrid_opengl || term->compositor->is_opengl) has_rgba = 1;
+ #endif
+ *vp = INT_TO_JSVAL( has_rgba );
+ }
+ else if (!strcmp(prop_name, "hardware_stretch")) {
+ *vp = INT_TO_JSVAL( (term->compositor->video_out->hw_caps & GF_VIDEO_HW_HAS_STRETCH) ? 1 : 0 );
+ }
+ else if (!strcmp(prop_name, "screen_width")) {
+ *vp = INT_TO_JSVAL( term->compositor->video_out->max_screen_width);
+ }
+ else if (!strcmp(prop_name, "screen_height")) {
+ *vp = INT_TO_JSVAL( term->compositor->video_out->max_screen_height);
+ }
+ else if (!strcmp(prop_name, "http_bitrate")) {
+ *vp = INT_TO_JSVAL( gf_dm_get_data_rate(term->downloader)*8/1024);
+ }
+ else if (!strcmp(prop_name, "fps")) {
+ Double fps = gf_sc_get_fps(term->compositor, 0);
+ *vp = DOUBLE_TO_JSVAL(JS_NewDouble(c, fps) );
+ }
+ else if (!strcmp(prop_name, "cpu_load")) {
+ GF_GPACJSExt *ext = (GF_GPACJSExt *)SMJS_GET_PRIVATE(c, obj);
+ gf_sys_get_rti(ext->rti_refresh_rate, &ext->rti, 0);
+ *vp = INT_TO_JSVAL(ext->rti.process_cpu_usage);
+ }
+ else if (!strcmp(prop_name, "memory")) {
+ GF_GPACJSExt *ext = (GF_GPACJSExt *)SMJS_GET_PRIVATE(c, obj);
+ gf_sys_get_rti(ext->rti_refresh_rate, &ext->rti, 0);
+ *vp = INT_TO_JSVAL(ext->rti.process_memory);
+ }
-SMJS_FREE(c, prop_name);
-return JS_TRUE;
+
+ SMJS_FREE(c, prop_name);
+ return JS_TRUE;
}
+
+
static SMJS_FUNC_PROP_SET( gpac_setProperty)
-char *prop_name, *prop_val;
-GF_Terminal *term = gpac_get_term(c, obj);
-if (!term) return JS_FALSE;
+ char *prop_name, *prop_val;
+ GF_Terminal *term = gpac_get_term(c, obj);
+ if (!term) return JS_FALSE;
-if (!SMJS_ID_IS_STRING(id)) return JS_TRUE;
-prop_name = SMJS_CHARS_FROM_STRING(c, SMJS_ID_TO_STRING(id));
+ if (!SMJS_ID_IS_STRING(id)) return JS_TRUE;
+ prop_name = SMJS_CHARS_FROM_STRING(c, SMJS_ID_TO_STRING(id));
-if (!strcmp(prop_name, "last_working_directory")) {
- if (!JSVAL_IS_STRING(*vp)) {
- SMJS_FREE(c, prop_name);
- return JS_FALSE;
+ if (!strcmp(prop_name, "last_working_directory")) {
+ if (!JSVAL_IS_STRING(*vp)) {
+ SMJS_FREE(c, prop_name);
+ return JS_FALSE;
+ }
+ prop_val = SMJS_CHARS(c, *vp);
+ gf_cfg_set_key(term->user->config, "General", "LastWorkingDir", prop_val);
+ SMJS_FREE(c, prop_val);
}
- prop_val = SMJS_CHARS(c, *vp);
- gf_cfg_set_key(term->user->config, "General", "LastWorkingDir", prop_val);
- SMJS_FREE(c, prop_val);
-}
-else if (!strcmp(prop_name, "caption")) {
- GF_Event evt;
- if (!JSVAL_IS_STRING(*vp)) {
- SMJS_FREE(c, prop_name);
- return JS_FALSE;
- }
- evt.type = GF_EVENT_SET_CAPTION;
- evt.caption.caption = SMJS_CHARS(c, *vp);
- gf_term_user_event(term, &evt);
- SMJS_FREE(c, (char*)evt.caption.caption);
-}
-else if (!strcmp(prop_name, "fullscreen")) {
- /*no fullscreen for iOS (always on)*/
-#ifndef GPAC_IPHONE
- Bool res = (JSVAL_TO_BOOLEAN(*vp)==JS_TRUE) ? 1 : 0;
- if (term->compositor->fullscreen != res) {
- gf_term_set_option(term, GF_OPT_FULLSCREEN, res);
+ else if (!strcmp(prop_name, "caption")) {
+ GF_Event evt;
+ if (!JSVAL_IS_STRING(*vp)) {
+ SMJS_FREE(c, prop_name);
+ return JS_FALSE;
+ }
+ evt.type = GF_EVENT_SET_CAPTION;
+ evt.caption.caption = SMJS_CHARS(c, *vp);
+ gf_term_user_event(term, &evt);
+ SMJS_FREE(c, (char*)evt.caption.caption);
}
-#endif
-}
-else if (!strcmp(prop_name, "volume")) {
- if (JSVAL_IS_NUMBER(*vp)) {
- jsdouble d;
- JS_ValueToNumber(c, *vp, &d);
- gf_term_set_option(term, GF_OPT_AUDIO_VOLUME, (u32) d);
- } else if (JSVAL_IS_INT(*vp)) {
- gf_term_set_option(term, GF_OPT_AUDIO_VOLUME, JSVAL_TO_INT(*vp));
+ else if (!strcmp(prop_name, "fullscreen")) {
+ /*no fullscreen for iOS (always on)*/
+ #ifndef GPAC_IPHONE
+ Bool res = (JSVAL_TO_BOOLEAN(*vp)==JS_TRUE) ? 1 : 0;
+ if (term->compositor->fullscreen != res) {
+ gf_term_set_option(term, GF_OPT_FULLSCREEN, res);
+ }
+ #endif
}
-}
-else if (!strcmp(prop_name, "navigation")) {
- gf_term_set_option(term, GF_OPT_NAVIGATION, JSVAL_TO_INT(*vp) );
-}
-else if (!strcmp(prop_name, "navigation_type")) {
- gf_term_set_option(term, GF_OPT_NAVIGATION_TYPE, 0);
-}
-else if (!strcmp(prop_name, "disable_hardware_blit")) {
- term->compositor->disable_hardware_blit = JSVAL_TO_INT(*vp) ? 1 : 0;
- gf_sc_set_option(term->compositor, GF_OPT_REFRESH, 0);
-}
-else if (!strcmp(prop_name, "disable_composite_blit")) {
- Bool new_val = JSVAL_TO_INT(*vp) ? 1 : 0;
- if (new_val != term->compositor->disable_composite_blit) {
- term->compositor->disable_composite_blit = new_val;
- term->compositor->rebuild_offscreen_textures = 1;
+ else if (!strcmp(prop_name, "volume")) {
+ if (JSVAL_IS_NUMBER(*vp)) {
+ jsdouble d;
+ JS_ValueToNumber(c, *vp, &d);
+ gf_term_set_option(term, GF_OPT_AUDIO_VOLUME, (u32) d);
+ } else if (JSVAL_IS_INT(*vp)) {
+ gf_term_set_option(term, GF_OPT_AUDIO_VOLUME, JSVAL_TO_INT(*vp));
+ }
+ }
+ else if (!strcmp(prop_name, "navigation")) {
+ gf_term_set_option(term, GF_OPT_NAVIGATION, JSVAL_TO_INT(*vp) );
+ }
+ else if (!strcmp(prop_name, "navigation_type")) {
+ gf_term_set_option(term, GF_OPT_NAVIGATION_TYPE, 0);
+ }
+ else if (!strcmp(prop_name, "disable_hardware_blit")) {
+ term->compositor->disable_hardware_blit = JSVAL_TO_INT(*vp) ? 1 : 0;
gf_sc_set_option(term->compositor, GF_OPT_REFRESH, 0);
}
-}
-else if (!strcmp(prop_name, "http_bitrate")) {
- u32 new_rate = JSVAL_TO_INT(*vp);
- gf_dm_set_data_rate(term->downloader, new_rate);
-}
+ else if (!strcmp(prop_name, "disable_composite_blit")) {
+ Bool new_val = JSVAL_TO_INT(*vp) ? 1 : 0;
+ if (new_val != term->compositor->disable_composite_blit) {
+ term->compositor->disable_composite_blit = new_val;
+ term->compositor->rebuild_offscreen_textures = 1;
+ gf_sc_set_option(term->compositor, GF_OPT_REFRESH, 0);
+ }
+ }
+ else if (!strcmp(prop_name, "http_bitrate")) {
+ u32 new_rate = JSVAL_TO_INT(*vp);
+ gf_dm_set_data_rate(term->downloader, new_rate);
+ }
-SMJS_FREE(c, prop_name);
-return JS_TRUE;
+ SMJS_FREE(c, prop_name);
+ return JS_TRUE;
}
static JSBool SMJS_FUNCTION(gpac_getOption)
{
const char *opt;
char *sec_name, *key_name;
+ s32 idx = -1;
JSString *s;
SMJS_OBJ
SMJS_ARGS
if (argc < 2) return JS_FALSE;
if (!JSVAL_IS_STRING(argv[0])) return JS_FALSE;
- if (!JSVAL_IS_STRING(argv[1])) return JS_FALSE;
+ if (!JSVAL_IS_STRING(argv[1]) && !JSVAL_IS_INT(argv[1])) return JS_FALSE;
sec_name = SMJS_CHARS(c, argv[0]);
- key_name = SMJS_CHARS(c, argv[1]);
+ key_name = NULL;
+ if (JSVAL_IS_INT(argv[1])) {
+ idx = JSVAL_TO_INT(argv[1]);
+ } else if (JSVAL_IS_STRING(argv[1]) ) {
+ key_name = SMJS_CHARS(c, argv[1]);
+ }
if (!stricmp(sec_name, "audiofilters")) {
if (!term->compositor->audio_renderer->filter_chain.enable_filters
return JS_TRUE;
}
opt = term->compositor->audio_renderer->filter_chain.filters->filter->GetOption(term->compositor->audio_renderer->filter_chain.filters->filter, key_name);
- } else {
+ } else if (key_name) {
opt = gf_cfg_get_key(term->user->config, sec_name, key_name);
+ } else if (idx>=0) {
+ opt = gf_cfg_get_key_name(term->user->config, sec_name, idx);
+ }
+ if (key_name) {
+ SMJS_FREE(c, key_name);
}
- SMJS_FREE(c, key_name);
SMJS_FREE(c, sec_name);
- s = JS_NewStringCopyZ(c, opt ? opt : "");
- if (!s) return JS_FALSE;
- SMJS_SET_RVAL( STRING_TO_JSVAL(s) );
+ if (opt) {
+ s = JS_NewStringCopyZ(c, opt);
+ SMJS_SET_RVAL( STRING_TO_JSVAL(s) );
+ } else {
+ SMJS_SET_RVAL( JSVAL_NULL );
+ }
return JS_TRUE;
}
Bool is_dir;
} enum_dir_cbk;
-static Bool enum_dir_fct(void *cbck, char *file_name, char *file_path)
+static Bool enum_dir_fct(void *cbck, char *file_name, char *file_path, GF_FileEnumInfo *file_info)
{
u32 i, len;
char *sep;
}
JS_DefineProperty(cbk->c, obj, "path", STRING_TO_JSVAL(s), 0, 0, JSPROP_READONLY | JSPROP_PERMANENT);
JS_DefineProperty(cbk->c, obj, "directory", BOOLEAN_TO_JSVAL(cbk->is_dir ? JS_TRUE : JS_FALSE), 0, 0, JSPROP_READONLY | JSPROP_PERMANENT);
+ JS_DefineProperty(cbk->c, obj, "drive", BOOLEAN_TO_JSVAL(file_info->drive ? JS_TRUE : JS_FALSE), 0, 0, JSPROP_READONLY | JSPROP_PERMANENT);
+ JS_DefineProperty(cbk->c, obj, "hidden", BOOLEAN_TO_JSVAL(file_info->hidden ? JS_TRUE : JS_FALSE), 0, 0, JSPROP_READONLY | JSPROP_PERMANENT);
+ JS_DefineProperty(cbk->c, obj, "system", BOOLEAN_TO_JSVAL(file_info->system ? JS_TRUE : JS_FALSE), 0, 0, JSPROP_READONLY | JSPROP_PERMANENT);
+ JS_DefineProperty(cbk->c, obj, "size", INT_TO_JSVAL(file_info->size), 0, 0, JSPROP_READONLY | JSPROP_PERMANENT);
+ JS_DefineProperty(cbk->c, obj, "last_modified", INT_TO_JSVAL(file_info->last_modified), 0, 0, JSPROP_READONLY | JSPROP_PERMANENT);
+
JS_GetArrayLength(cbk->c, cbk->array, &idx);
v = OBJECT_TO_JSVAL(obj);
if ((dir[1]==':') && ((dir[2]=='/') || (dir[2]=='\\')) ) browse_root = 1;
else if (!strcmp(dir, "/")) browse_root = 1;
}
+ if (!strcmp(url, "/")) browse_root = 1;
}
}
return JS_TRUE;
}
+static JSBool SMJS_FUNCTION(gpac_trigger_gc)
+{
+ SMJS_OBJ
+ SMJS_ARGS
+ GF_SceneGraph *sg = NULL;
+ GF_Terminal *term = gpac_get_term(c, obj);
+
+ sg = term->root_scene->graph;
+ sg->trigger_gc = GF_TRUE;
+ return JS_TRUE;
+}
+
static JSBool SMJS_FUNCTION(gpac_migrate_url)
{
char *url;
static SMJS_FUNC_PROP_GET( gpacevt_getProperty)
-GF_GPACJSExt *gjs = SMJS_GET_PRIVATE(c, obj);
-GF_Event *evt = gjs->evt;
-if (!evt) return 0;
+ GF_GPACJSExt *gjs = SMJS_GET_PRIVATE(c, obj);
+ GF_Event *evt = gjs->evt;
+ if (!evt) return 0;
-if (SMJS_ID_IS_INT(id)) {
- switch (SMJS_ID_TO_INT(id)) {
- case -1:
+ if (SMJS_ID_IS_INT(id)) {
+ switch (SMJS_ID_TO_INT(id)) {
+ case -1:
#ifndef GPAC_DISABLE_SVG
- *vp = STRING_TO_JSVAL(JS_NewStringCopyZ(c, gf_dom_get_key_name(evt->key.key_code) ));
+ *vp = STRING_TO_JSVAL(JS_NewStringCopyZ(c, gf_dom_get_key_name(evt->key.key_code) ));
#endif
- break;
- case -2:
- *vp = INT_TO_JSVAL(evt->mouse.x);
- break;
- case -3:
- *vp = INT_TO_JSVAL(evt->mouse.y);
- break;
- case -4:
- if (gjs->term->compositor->hit_appear) *vp = BOOLEAN_TO_JSVAL(JS_TRUE);
- else if (gf_list_count(gjs->term->compositor->previous_sensors) ) *vp = BOOLEAN_TO_JSVAL(JS_TRUE);
- else if (gjs->term->compositor->text_selection) *vp = BOOLEAN_TO_JSVAL(JS_TRUE);
- else *vp = BOOLEAN_TO_JSVAL(JS_FALSE);
- break;
- case -5:
- *vp = DOUBLE_TO_JSVAL( JS_NewDouble(c, FIX2FLT(evt->mouse.wheel_pos)) );
- break;
- case -6:
- *vp = INT_TO_JSVAL( evt->mouse.button);
- break;
- case -7:
- *vp = INT_TO_JSVAL(evt->type);
- break;
- }
-} else if (SMJS_ID_IS_STRING(id)) {
- char *name = SMJS_CHARS_FROM_STRING(c, SMJS_ID_TO_STRING(id));
- if (!strcmp(name, "target_url")) {
- *vp = STRING_TO_JSVAL( JS_NewStringCopyZ(c, evt->navigate.to_url) );
- }
- else if (!strcmp(name, "files")) {
- u32 i, idx;
- jsval v;
- JSObject *files_array = JS_NewArrayObject(c, 0, NULL);
- for (i=0; i<evt->open_file.nb_files; i++) {
- if (evt->open_file.files[i]) {
- JS_GetArrayLength(c, files_array, &idx);
- v = STRING_TO_JSVAL( JS_NewStringCopyZ(c, evt->open_file.files[i]) );
- JS_SetElement(c, files_array, idx, &v);
+ break;
+ case -2:
+ *vp = INT_TO_JSVAL(evt->mouse.x);
+ break;
+ case -3:
+ *vp = INT_TO_JSVAL(evt->mouse.y);
+ break;
+ case -4:
+ if (gjs->term->compositor->hit_appear) *vp = BOOLEAN_TO_JSVAL(JS_TRUE);
+ else if (gf_list_count(gjs->term->compositor->previous_sensors) ) *vp = BOOLEAN_TO_JSVAL(JS_TRUE);
+ else if (gjs->term->compositor->text_selection) *vp = BOOLEAN_TO_JSVAL(JS_TRUE);
+ else *vp = BOOLEAN_TO_JSVAL(JS_FALSE);
+ break;
+ case -5:
+ *vp = DOUBLE_TO_JSVAL( JS_NewDouble(c, FIX2FLT(evt->mouse.wheel_pos)) );
+ break;
+ case -6:
+ *vp = INT_TO_JSVAL( evt->mouse.button);
+ break;
+ case -7:
+ *vp = INT_TO_JSVAL(evt->type);
+ break;
+ case -8:
+#ifndef GPAC_DISABLE_SVG
+ *vp = STRING_TO_JSVAL(JS_NewStringCopyZ(c, gf_dom_event_get_name(evt->type) ));
+#endif
+ break;
+ }
+ } else if (SMJS_ID_IS_STRING(id)) {
+ char *name = SMJS_CHARS_FROM_STRING(c, SMJS_ID_TO_STRING(id));
+ if (!strcmp(name, "target_url")) {
+ *vp = STRING_TO_JSVAL( JS_NewStringCopyZ(c, evt->navigate.to_url) );
+ }
+ else if (!strcmp(name, "files")) {
+ u32 i, idx;
+ jsval v;
+ JSObject *files_array = JS_NewArrayObject(c, 0, NULL);
+ for (i=0; i<evt->open_file.nb_files; i++) {
+ if (evt->open_file.files[i]) {
+ JS_GetArrayLength(c, files_array, &idx);
+ v = STRING_TO_JSVAL( JS_NewStringCopyZ(c, evt->open_file.files[i]) );
+ JS_SetElement(c, files_array, idx, &v);
+ }
}
+ *vp = OBJECT_TO_JSVAL(files_array);
}
- *vp = OBJECT_TO_JSVAL(files_array);
+ SMJS_FREE(c, name);
}
- SMJS_FREE(c, name);
-}
-return JS_TRUE;
+ return JS_TRUE;
}
static Bool gjs_event_filter(void *udta, GF_Event *evt, Bool consumed_by_compositor)
GF_Terminal *term = gpac_get_term(c, obj);
if (!argc) return JS_FALSE;
+ if (JSVAL_IS_NULL(argv[0])) {
+ gf_sc_focus_switch_ring(term->compositor, 0, NULL, 0);
+ return JS_TRUE;
+ }
+
if (JSVAL_IS_STRING(argv[0])) {
char *focus_type = SMJS_CHARS(c, argv[0]);
if (!stricmp(focus_type, "previous")) {
SMJS_PROPERTY_SPEC("wheel", -5, JSPROP_ENUMERATE | JSPROP_PERMANENT | JSPROP_SHARED | JSPROP_READONLY, 0, 0),
SMJS_PROPERTY_SPEC("button", -6, JSPROP_ENUMERATE | JSPROP_PERMANENT | JSPROP_SHARED | JSPROP_READONLY, 0, 0),
SMJS_PROPERTY_SPEC("type", -7, JSPROP_ENUMERATE | JSPROP_PERMANENT | JSPROP_SHARED | JSPROP_READONLY, 0, 0),
+ SMJS_PROPERTY_SPEC("name", -8, JSPROP_ENUMERATE | JSPROP_PERMANENT | JSPROP_SHARED | JSPROP_READONLY, 0, 0),
SMJS_PROPERTY_SPEC(0, 0, 0, 0, 0)
};
JSFunctionSpec gpacEvtClassFuncs[] = {
SMJS_FUNCTION_SPEC("get_scene", gpac_get_scene, 1),
SMJS_FUNCTION_SPEC("error_string", gpac_error_string, 1),
SMJS_FUNCTION_SPEC("show_keyboard", gpac_show_keyboard, 1),
+ SMJS_FUNCTION_SPEC("trigger_gc", gpac_trigger_gc, 1),
SMJS_FUNCTION_SPEC(0, 0, 0)
DECLARE_GPAC_CONST(GF_EVENT_CONNECT);
DECLARE_GPAC_CONST(GF_EVENT_NAVIGATE_INFO);
DECLARE_GPAC_CONST(GF_EVENT_NAVIGATE);
- DECLARE_GPAC_CONST(GF_EVENT_OPENFILE);
+ DECLARE_GPAC_CONST(GF_EVENT_DROPFILE);
DECLARE_GPAC_CONST(GF_NAVIGATE_NONE);
DECLARE_GPAC_CONST(GF_NAVIGATE_WALK);
if (group->segment_ifce == ifce) {
//if sync is based on timestamps do not adjust the timestamps back
if (! group->is_timestamp_based) {
- u32 idx, timescale;
+ u32 timescale;
u64 pto=0;
gf_dash_group_get_presentation_time_offset(mpdin->dash, i, &pto, ×cale);
if (timescale && (timescale != ch->esd->slConfig->timestampResolution)) {
com.base.command_type = GF_NET_SERVICE_MEDIA_CAP_QUERY;
gf_service_command(serv, &com, GF_OK);
- com.mcaps.width = 1920;
- com.mcaps.height = 1080;
if (com.mcaps.width && com.mcaps.height) {
gf_dash_set_max_resolution(mpdin->dash, com.mcaps.width, com.mcaps.height, com.mcaps.display_bit_depth);
}
u64 pto;
Double offset;
gf_dash_group_get_presentation_time_offset(mpdin->dash, idx, &pto, ×cale);
- offset = pto;
+ offset = (Double) pto;
offset /= timescale;
com->play.start_range -= offset;
if (com->play.start_range < 0) com->play.start_range = 0;
if (!ctx->conv_to_8bit && ctx->direct_output) {
*outBufferLength = ctx->out_size;
ctx->has_pic = GF_TRUE;
- } else {
- if (ctx->conv_to_8bit) {
- OpenHevc_Frame openHevcFramePtr;
- if (libOpenHevcGetOutput(ctx->openHevcHandle, 1, &openHevcFramePtr)) {
- GF_VideoSurface dst;
- memset(&dst, 0, sizeof(GF_VideoSurface));
- dst.width = ctx->width;
- dst.height = ctx->height;
- dst.pitch_y = ctx->width;
- dst.video_buffer = ctx->direct_output ? ctx->conv_buffer : outBuffer;
- dst.pixel_format = GF_PIXEL_YV12;
-
- gf_color_write_yv12_10_to_yuv(&dst, (u8 *) openHevcFramePtr.pvY, (u8 *) openHevcFramePtr.pvU, (u8 *) openHevcFramePtr.pvV, openHevcFramePtr.frameInfo.nYPitch, ctx->width, ctx->height, NULL);
- *outBufferLength = ctx->out_size;
-
- if (ctx->direct_output )
- ctx->has_pic = GF_TRUE;
- }
- } else if (ctx->pack_mode) {
- OpenHevc_Frame openHFrame;
- u8 *pY, *pU, *pV;
+ return GF_OK;
+ }
+
+ if (ctx->conv_to_8bit) {
+ OpenHevc_Frame openHevcFramePtr;
+ if (libOpenHevcGetOutput(ctx->openHevcHandle, 1, &openHevcFramePtr)) {
+ GF_VideoSurface dst;
+ memset(&dst, 0, sizeof(GF_VideoSurface));
+ dst.width = ctx->width;
+ dst.height = ctx->height;
+ dst.pitch_y = ctx->width;
+ dst.video_buffer = ctx->direct_output ? ctx->conv_buffer : outBuffer;
+ dst.pixel_format = GF_PIXEL_YV12;
+
+ gf_color_write_yv12_10_to_yuv(&dst, (u8 *) openHevcFramePtr.pvY, (u8 *) openHevcFramePtr.pvU, (u8 *) openHevcFramePtr.pvV, openHevcFramePtr.frameInfo.nYPitch, ctx->width, ctx->height, NULL, 0);
+ *outBufferLength = ctx->out_size;
+
+ if (ctx->direct_output )
+ ctx->has_pic = GF_TRUE;
+ }
+ return GF_OK;
+ }
+
+ if (ctx->pack_mode) {
+ OpenHevc_Frame openHFrame;
+ u8 *pY, *pU, *pV;
- u32 idx_w, idx_h;
- idx_w = ((ctx->frame_idx==0) || (ctx->frame_idx==2)) ? 0 : ctx->width;
- idx_h = ((ctx->frame_idx==0) || (ctx->frame_idx==1)) ? 0 : ctx->height*2*ctx->stride;
+ u32 idx_w, idx_h;
+ idx_w = ((ctx->frame_idx==0) || (ctx->frame_idx==2)) ? 0 : ctx->width;
+ idx_h = ((ctx->frame_idx==0) || (ctx->frame_idx==1)) ? 0 : ctx->height*2*ctx->stride;
- pY = (void*) ( outBuffer + idx_h + idx_w );
- pU = (void*) (outBuffer + 2*ctx->stride*2*ctx->height + idx_w/2 + idx_h/4);
- pV = (void*) (outBuffer + 2*ctx->stride*2*ctx->height + ctx->stride*ctx->height + idx_w/2 + idx_h/4);
+ pY = (void*) ( outBuffer + idx_h + idx_w );
+ pU = (void*) (outBuffer + 2*ctx->stride*2*ctx->height + idx_w/2 + idx_h/4);
+ pV = (void*) (outBuffer + 2*ctx->stride*2*ctx->height + ctx->stride*ctx->height + idx_w/2 + idx_h/4);
- *outBufferLength = 0;
- if (libOpenHevcGetOutput(ctx->openHevcHandle, 1, &openHFrame)) {
- u32 i, s_stride, qs_stride, d_stride, dd_stride, hd_stride;
+ *outBufferLength = 0;
+ if (libOpenHevcGetOutput(ctx->openHevcHandle, 1, &openHFrame)) {
+ u32 i, s_stride, qs_stride, d_stride, dd_stride, hd_stride;
- s_stride = openHFrame.frameInfo.nYPitch;
- qs_stride = s_stride / 4;
+ s_stride = openHFrame.frameInfo.nYPitch;
+ qs_stride = s_stride / 4;
- d_stride = ctx->stride;
- dd_stride = 2*ctx->stride;
- hd_stride = ctx->stride/2;
+ d_stride = ctx->stride;
+ dd_stride = 2*ctx->stride;
+ hd_stride = ctx->stride/2;
- for (i=0; i<ctx->height; i++) {
- memcpy(pY, (u8 *) openHFrame.pvY + i*s_stride, d_stride);
- pY += dd_stride;
+ for (i=0; i<ctx->height; i++) {
+ memcpy(pY, (u8 *) openHFrame.pvY + i*s_stride, d_stride);
+ pY += dd_stride;
- if (! (i%2) ) {
- memcpy(pU, (u8 *) openHFrame.pvU + i*qs_stride, hd_stride);
- pU += d_stride;
+ if (! (i%2) ) {
+ memcpy(pU, (u8 *) openHFrame.pvU + i*qs_stride, hd_stride);
+ pU += d_stride;
- memcpy(pV, (u8 *) openHFrame.pvV + i*qs_stride, hd_stride);
- pV += d_stride;
- }
+ memcpy(pV, (u8 *) openHFrame.pvV + i*qs_stride, hd_stride);
+ pV += d_stride;
}
-
- ctx->frame_idx++;
- if (ctx->frame_idx==4) {
- *outBufferLength = 4 * ctx->out_size;
- ctx->frame_idx = 0;
- }
- }
- } else {
- openHevcFrame.pvY = (void*) outBuffer;
- openHevcFrame.pvU = (void*) (outBuffer + ctx->stride * ctx->height);
- openHevcFrame.pvV = (void*) (outBuffer + 5*ctx->stride * ctx->height/4);
- *outBufferLength = 0;
- if (libOpenHevcGetOutputCpy(ctx->openHevcHandle, 1, &openHevcFrame)) {
- *outBufferLength = ctx->out_size;
}
+
+ ctx->frame_idx++;
+ if (ctx->frame_idx==4) {
+ *outBufferLength = 4 * ctx->out_size;
+ ctx->frame_idx = 0;
+ }
}
+ return GF_OK;
+ }
+
+
+ openHevcFrame.pvY = (void*) outBuffer;
+ openHevcFrame.pvU = (void*) (outBuffer + ctx->stride * ctx->height);
+ openHevcFrame.pvV = (void*) (outBuffer + 5*ctx->stride * ctx->height/4);
+ *outBufferLength = 0;
+ if (libOpenHevcGetOutputCpy(ctx->openHevcHandle, 1, &openHevcFrame)) {
+ *outBufferLength = ctx->out_size;
}
return GF_OK;
}
}
-static Bool wm_enum_widget(void *cbk, char *file_name, char *file_path)
+static Bool wm_enum_widget(void *cbk, char *file_name, char *file_path, GF_FileEnumInfo *file_info)
{
GF_WidgetInstance *wid;
GF_WidgetManager *wm = (GF_WidgetManager *)cbk;
return 0;
}
-static Bool wm_enum_dir(void *cbk, char *file_name, char *file_path)
+static Bool wm_enum_dir(void *cbk, char *file_name, char *file_path, GF_FileEnumInfo *file_info)
{
return (gf_enum_directory(file_path, 0, wm_enum_widget, cbk, "mgt")==GF_OK) ? GF_FALSE : GF_TRUE;
}
/*set isActive - to clarify in the specs*/
node->isActive = 1;
- gf_node_event_out_str((GF_Node *)node, "isActive");
+ gf_node_event_out((GF_Node *)node, 3/*"isActive"*/);
if (!node->buffer.bufferSize) return;
/*we may replace ourselves*/
GF_SceneGraph *sg;
#endif
GF_List *temp_queue;
- u32 in_time, end_time, i, count;
+ u32 in_time, end_time, i, count, frame_duration;
Bool frame_drawn, has_timed_nodes=GF_FALSE, all_tx_done=GF_TRUE;
#ifndef GPAC_DISABLE_LOG
s32 event_time, route_time, smil_timing_time=0, time_node_time, texture_time, traverse_time, flush_time, txtime;
#endif
- in_time = gf_sys_clock();
/*lock compositor for the whole cycle*/
gf_sc_lock(compositor, 1);
+ in_time = gf_sys_clock();
+
gf_sc_texture_cleanup_hw(compositor);
/*first thing to do, let the video output handle user event if it is not threaded*/
//first update all natural textures to figure out timing
compositor->frame_delay = (u32) -1;
compositor->next_frame_delay = (u32) -1;
+ frame_duration = compositor->frame_duration;
#ifndef GPAC_DISABLE_LOG
texture_time = gf_sys_clock();
if (compositor->reset_graphics && txh->tx_io) gf_sc_texture_reset(txh);
txh->update_texture_fcnt(txh);
- if (!txh->stream_finished) all_tx_done=0;
+ if (!txh->stream_finished) {
+ u32 d = gf_mo_get_min_frame_dur(txh->stream);
+ if (d && (d < frame_duration)) frame_duration = d;
+
+ all_tx_done=0;
+ }
}
//it may happen that we have a reconfigure request at this stage, especially if updating one of the textures
texture_time = gf_sys_clock() - texture_time;
#endif
- //this is correct but doesn't bring much and we may actually waste time while sleeping that could be used for texture upload - we prefer sleeping at the end of the pass
-#if 0
- //if next video frame is due in this render cycle, wait until it matures
- if ((compositor->frame_delay > 0) && (compositor->frame_delay != (u32) -1)) {
- u32 diff=0;
- compositor->frame_delay = MIN(compositor->frame_delay, (s32) compositor->frame_duration);
- while (!compositor->video_frame_pending) {
- gf_sleep(0);
- diff = gf_sys_clock() - in_time;
- if (diff >= (u32) compositor->frame_delay)
- break;
- }
- GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("[Compositor] Waited %d ms for next frame and %d ms was required\n", diff, compositor->frame_delay));
- if (compositor->next_frame_delay != (u32) -1) {
- if (diff < compositor->next_frame_delay) compositor->next_frame_delay -= diff;
- else compositor->next_frame_delay = 1;
- }
- }
-#endif
-
-
-
-#ifndef GPAC_DISABLE_SVG
-#if SVG_FIXME
- { /* Experimental (Not SVG compliant system events (i.e. battery, cpu ...) triggered to the root node)*/
- GF_Node *root = gf_sg_get_root_node(compositor->scene);
- GF_DOM_Event evt;
- if (gf_dom_listener_count(root)) {
- u32 i, count;
- count = gf_dom_listener_count(root);
- for (i=0; i<count; i++) {
- SVG_SA_listenerElement *l = gf_dom_listener_get(root, i);
- if (l->event.type == GF_EVENT_CPU) {
- GF_SystemRTInfo sys_rti;
- if (gf_sys_get_rti(500, &sys_rti, GF_RTI_ALL_PROCESSES_TIMES)) {
- evt.type = GF_EVENT_CPU;
- evt.cpu_percentage = sys_rti.total_cpu_usage;
- //fprintf(stderr, "%d\n",sys_rti.total_cpu_usage);
- gf_dom_event_fire(root, NULL, &evt);
- }
- } else if (l->event.type == GF_EVENT_BATTERY) { //&& l->observer.target == (SVG_SA_Element *)node) {
- evt.type = GF_EVENT_BATTERY;
- gf_sys_get_battery_state(&evt.onBattery, &evt.batteryState, &evt.batteryLevel, NULL, NULL);
- gf_dom_event_fire(root, NULL, &evt);
- }
- }
- }
- }
-#endif
-#endif //GPAC_DISABLE_SVG
-
#ifndef GPAC_DISABLE_SVG
#endif /*GPAC_DISABLE_VRML*/
-
/*setup root visual BEFORE updating the composite textures (since they may depend on root setup)*/
gf_sc_setup_root_visual(compositor, gf_sg_get_root_node(compositor->scene));
txtime = gf_sys_clock();
#endif
/*update all composite textures*/
+ compositor->texture_inserted = GF_FALSE;
count = gf_list_count(compositor->textures);
for (i=0; i<count; i++) {
GF_TextureHandler *txh = (GF_TextureHandler *)gf_list_get(compositor->textures, i);
/*signal graphics reset before updating*/
if (compositor->reset_graphics && txh->tx_io) gf_sc_texture_reset(txh);
txh->update_texture_fcnt(txh);
+ if (compositor->texture_inserted) {
+ compositor->texture_inserted = GF_FALSE;
+ count = gf_list_count(compositor->textures);
+ i = gf_list_find(compositor->textures, txh);
+ }
}
//it may happen that we have a reconfigure request at this stage, especially if updating one of the textures update
//forced a relayout - do it right away
if (compositor->msg_type) {
+ //reset AR recompute flag, it will be reset when msg is handled
+ compositor->recompute_ar = 0;
gf_sc_lock(compositor, 0);
return;
}
}
if (compositor->is_hidden) {
-#if 0
- gf_sc_lock(compositor, 0);
- if (compositor->no_regulation) return;
- gf_sleep(compositor->frame_duration);
- return;
-#else
compositor->frame_draw_type = 0;
-#endif
}
frame_drawn = (compositor->frame_draw_type==GF_SC_DRAW_FRAME) ? 1 : 0;
}
if (compositor->bench_mode && (frame_drawn || (has_timed_nodes&&all_tx_done) )) {
//in bench mode we always increase the clock of the fixed target simulation rate - this needs refinement if video is used ...
- compositor->scene_sampled_clock += compositor->frame_duration;
+ compositor->scene_sampled_clock += frame_duration;
}
compositor->video_frame_pending=0;
gf_sc_lock(compositor, 0);
if (compositor->next_frame_delay>end_time) compositor->next_frame_delay-=end_time;
else compositor->next_frame_delay=0;
- compositor->next_frame_delay = MIN(compositor->next_frame_delay, 2*compositor->frame_duration);
+ compositor->next_frame_delay = MIN(compositor->next_frame_delay, 2*frame_duration);
if (compositor->next_frame_delay>2) {
u32 diff=0;
while (! compositor->msg_type && ! compositor->video_frame_pending) {
return;
}
- if (end_time > compositor->frame_duration) {
+ if (end_time > frame_duration) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[Compositor] Compositor did not go to sleep\n"));
return;
}
/*compute sleep time till next frame*/
- end_time %= compositor->frame_duration;
- gf_sleep(compositor->frame_duration - end_time);
- GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[Compositor] Compositor slept for %d ms\n", compositor->frame_duration - end_time));
+ end_time %= frame_duration;
+ gf_sleep(frame_duration - end_time);
+ GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[Compositor] Compositor slept for %d ms\n", frame_duration - end_time));
}
Bool gf_sc_visual_is_registered(GF_Compositor *compositor, GF_VisualManager *visual)
if (from_user) compositor->msg_type &= ~GF_SR_CFG_WINDOWSIZE_NOTIF;
} else {
/*remove pending resize notif*/
- if (!compositor->new_width)
- compositor->msg_type = 0;
+ compositor->msg_type &= ~GF_SR_CFG_SET_SIZE;
}
if (lock_ok) gf_sc_lock(compositor, GF_FALSE);
}
Bool del = 0;
GF_QueuedEvent *qev = gf_list_get(evq, i);
if (qev->node) {
- if (node && qev->node)
+ if (node == qev->node)
del = 1;
if (sg && (gf_node_get_graph(qev->node)==sg))
del = 1;
}
- if (qev->sg==sg)
+ if (qev->sg && (qev->sg==sg))
del = 1;
else if (qev->target && (qev->target->ptr_type == GF_DOM_EVENT_TARGET_NODE)) {
if (node && ((GF_Node *)qev->target->ptr==node))
#ifndef GPAC_DISABLE_3D
-void compositor_2d_hybgl_clear_surface_ex(GF_VisualManager *visual, GF_IRect *rc, u32 BackColor, Bool is_offscreen_clear)
+void compositor_2d_hybgl_clear_surface(GF_VisualManager *visual, GF_IRect *rc, u32 BackColor, Bool is_offscreen_clear)
{
SFColor rgb;
+ Fixed alpha = INT2FIX( GF_COL_A(BackColor) )/255;
if (!visual->is_attached) return;
if (!BackColor && !visual->offscreen) {
ra_union_rect(&visual->hybgl_drawn, rc);
}
} else {
- Fixed a;
rgb.red = INT2FIX( GF_COL_R(BackColor) ) / 255;
rgb.green = INT2FIX( GF_COL_G(BackColor) )/255;
rgb.blue = INT2FIX( GF_COL_B(BackColor) )/255;
- a = INT2FIX( GF_COL_A(BackColor) )/255;
- visual_3d_clear(visual, rgb , a);
+ visual_3d_clear(visual, rgb , alpha);
}
}
-void compositor_2d_hybgl_clear_surface(GF_VisualManager *visual, GF_IRect *rc, u32 BackColor)
-{
- compositor_2d_hybgl_clear_surface_ex(visual, rc, BackColor, 1);
-}
void compositor_2d_hybgl_flush_video(GF_Compositor *compositor, GF_IRect *area)
o_rc.width = dst_wnd.w;
o_rc.height = dst_wnd.h;
- visual->ClearSurface(visual, &o_rc, visual->compositor->video_out->overlay_color_key);
+ visual->ClearSurface(visual, &o_rc, visual->compositor->video_out->overlay_color_key, 0);
visual->has_overlays = GF_TRUE;
/*mark drawable as overlay*/
ctx->drawable->flags |= DRAWABLE_IS_OVERLAY;
StrikeInfo2D *si;
Fixed x, y;
u32 i, count;
+ GF_Node *appear = tr_state->override_appearance ? tr_state->override_appearance : tr_state->appear;
GF_Compositor *compositor = tr_state->visual->compositor;
#ifndef GPAC_DISABLE_3D
}
if (asp.pen_props.width || asp.line_texture ) {
- si = drawable_get_strikeinfo(tr_state->visual->compositor, drawable, &asp, tr_state->appear, NULL, 0, NULL);
+ si = drawable_get_strikeinfo(tr_state->visual->compositor, drawable, &asp, appear, NULL, 0, NULL);
if (si && si->outline && gf_path_point_over(si->outline, x, y)) {
goto picked;
}
compositor->hit_texcoords.y = FIX_ONE - gf_divfix(drawable->path->bbox.y - y, drawable->path->bbox.height);
#ifndef GPAC_DISABLE_VRML
- if (compositor_is_composite_texture(tr_state->appear)) {
- compositor->hit_appear = tr_state->appear;
+ if (compositor_is_composite_texture(appear)) {
+ compositor->hit_appear = appear;
} else
#endif
{
M_Material2D *m = NULL;
M_LineProperties *LP;
M_XLineProperties *XLP;
+ GF_Node *appear = tr_state->override_appearance ? tr_state->override_appearance : tr_state->appear;
u32 ret = 0;
asp->pen_props.cap = GF_LINE_CAP_FLAT;
asp->line_color = 0xFFCCCCCC;
asp->pen_props.width = 0;
- if (tr_state->appear == NULL) goto check_default;
+ if (appear == NULL) goto check_default;
- if ( ((M_Appearance *) tr_state->appear)->texture ) {
- asp->fill_texture = gf_sc_texture_get_handler( ((M_Appearance *) tr_state->appear)->texture );
+ if ( ((M_Appearance *) appear)->texture ) {
+ asp->fill_texture = gf_sc_texture_get_handler( ((M_Appearance *) appear)->texture );
}
- m = (M_Material2D *) ((M_Appearance *)tr_state->appear)->material;
+ m = (M_Material2D *) ((M_Appearance *)appear)->material;
if ( m == NULL) {
asp->fill_color &= 0x00FFFFFF;
goto check_default;
{
DrawableContext *ctx;
Bool skipFill;
+ GF_Node *appear;
#ifndef GPAC_DISABLE_3D
Bool texture_ready=0;
#endif
ctx->drawable = drawable;
+ appear = tr_state->override_appearance ? tr_state->override_appearance : tr_state->appear;
+
/*usually set by colorTransform or changes in OrderedGroup*/
if (tr_state->invalidate_all)
ctx->flags |= CTX_APP_DIRTY;
ctx->aspect.fill_texture = NULL;
- if (tr_state->appear) {
- ctx->appear = tr_state->appear;
- if (gf_node_dirty_get(tr_state->appear))
+ if (appear) {
+ ctx->appear = appear;
+ if (gf_node_dirty_get(appear))
ctx->flags |= CTX_APP_DIRTY;
}
/*todo cliper*/
#endif
Fixed pw;
GF_Rect unclip, store_orig_bounds;
+ GF_Node *appear = tr_state->override_appearance ? tr_state->override_appearance : tr_state->appear;
drawable_check_bounds(ctx, tr_state->visual);
#endif
/*get strike info & outline for exact bounds compute. If failure use default offset*/
- si = drawable_get_strikeinfo(tr_state->visual->compositor, ctx->drawable, &ctx->aspect, tr_state->appear, ctx->drawable->path, ctx->flags, NULL);
+ si = drawable_get_strikeinfo(tr_state->visual->compositor, ctx->drawable, &ctx->aspect, appear, ctx->drawable->path, ctx->flags, NULL);
if (si && si->outline) {
gf_path_get_bounds(si->outline, &ctx->bi->unclip);
gf_mx2d_apply_rect(&tr_state->transform, &ctx->bi->unclip);
DrawableContext *ctx;
assert(tr_state->visual);
+ /*setup SVG based on override appearance node */
+ if (tr_state->override_appearance) {
+ return drawable_init_context_mpeg4(drawable, tr_state);
+ }
+
/*switched-off geometry nodes are not drawn*/
if (tr_state->switched_off) return NULL;
compositor->sel_buffer_len = compositor->sel_buffer_alloc = 0;
compositor->edited_text = NULL;
- if (signal) {
+ if (compositor->focus_node && signal) {
memset(&info, 0, sizeof(GF_FieldInfo));
info.fieldIndex = (u32) -1;
if (compositor->focus_text_type>=3) {
} else
#endif /*GPAC_DISABLE_VRML*/
- {
+ if (compositor->focus_node) {
#ifndef GPAC_DISABLE_SVG
GF_ChildNodeItem *child = ((GF_ParentNode *) compositor->focus_node)->children;
flush_text_node_edit(compositor, 1);
}
- if (*res) {
+ if (res && *res) {
const char *src = *res;
compositor->sel_buffer_alloc = 2 + (u32) strlen(src);
compositor->sel_buffer = gf_realloc(compositor->sel_buffer, sizeof(u16)*compositor->sel_buffer_alloc);
if (sr->keynav_node) {
kn = (M_KeyNavigator*)sr->keynav_node;
kn->focusSet = 0;
- gf_node_event_out_str(sr->keynav_node, "focusSet");
+ gf_node_event_out(sr->keynav_node, 9/*"focusSet"*/);
}
sr->keynav_node = n;
kn = (M_KeyNavigator*)n;
if (n) {
kn->focusSet = 1;
- gf_node_event_out_str(sr->keynav_node, "focusSet");
+ gf_node_event_out(sr->keynav_node, 9/*"focusSet"*/);
}
par = n ? kn->sensor : NULL;
}
}
+
+
+/*StyleGroup: overrides appearance of all children*/
+typedef struct
+{
+ BASE_NODE
+ CHILDREN
+
+ GF_Node *appearance;
+} StyleGroup;
+
+typedef struct
+{
+ GROUPING_MPEG4_STACK_2D
+ StyleGroup sg;
+} StyleGroupStack;
+
+static Bool StyleGroup_GetNode(GF_Node *node, StyleGroup *sg)
+{
+ GF_FieldInfo field;
+ memset(sg, 0, sizeof(StyleGroup));
+ sg->sgprivate = node->sgprivate;
+
+ if (gf_node_get_field(node, 0, &field) != GF_OK) return 0;
+ if (field.fieldType != GF_SG_VRML_MFNODE) return 0;
+ sg->children = *(GF_ChildNodeItem **) field.far_ptr;
+
+ if (gf_node_get_field(node, 1, &field) != GF_OK) return 0;
+ if (field.fieldType != GF_SG_VRML_SFNODE) return 0;
+ sg->appearance = *(GF_Node **)field.far_ptr;
+
+ return 1;
+}
+
+
+static void TraverseStyleGroup(GF_Node *node, void *rs, Bool is_destroy)
+{
+ Bool set = 0;
+ StyleGroupStack *stack = (StyleGroupStack *)gf_node_get_private(node);
+ GF_TraverseState *tr_state = (GF_TraverseState *) rs;
+
+ if (is_destroy) {
+ gf_free(stack);
+ return;
+ }
+
+ if (tr_state->traversing_mode==TRAVERSE_SORT) {
+ if (gf_node_dirty_get(node) & GF_SG_NODE_DIRTY) {
+
+ gf_node_dirty_clear(node, GF_SG_NODE_DIRTY);
+ /*flag is not set for PROTO*/
+ gf_node_dirty_set(node, GF_SG_CHILD_DIRTY, 0);
+ }
+ }
+ StyleGroup_GetNode(node, &stack->sg);
+
+ if (!tr_state->override_appearance) {
+ set = 1;
+ tr_state->override_appearance = stack->sg.appearance;
+ }
+ group_2d_traverse((GF_Node *)&stack->sg, (GroupingNode2D*)stack, tr_state);
+
+ if (set) {
+ tr_state->override_appearance = NULL;
+ }
+}
+
+void compositor_init_style_group(GF_Compositor *compositor, GF_Node *node)
+{
+ StyleGroup sg;
+ if (StyleGroup_GetNode(node, &sg)) {
+ StyleGroupStack *stack;
+ GF_SAFEALLOC(stack, StyleGroupStack);
+ gf_node_set_private(node, stack);
+ gf_node_set_callback_function(node, TraverseStyleGroup);
+ stack->sg = sg;
+ gf_node_proto_set_grouping(node);
+ } else {
+ GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[Compositor2D] Unable to initialize style group\n"));
+ }
+}
+
+
/*hardcoded proto loading - this is mainly used for module development and testing...*/
void compositor_init_hardcoded_proto(GF_Compositor *compositor, GF_Node *node)
{
compositor_init_hc_flashshape(compositor, node);
return;
}
+ if (!strcmp(url, "urn:inet:gpac:builtin:StyleGroup")) {
+ compositor_init_style_group(compositor, node);
+ return;
+ }
/*check proto modules*/
if (compositor->proto_modules) {
{
animationstream_check_url(stack, as);
as->isActive = 1;
- gf_node_event_out_str((GF_Node*)as, "isActive");
+ gf_node_event_out((GF_Node*)as, 6/*"isActive"*/);
gf_mo_play(stack->stream, 0, -1, 0);
gf_mo_set_speed(stack->stream, as->speed);
{
if (as->isActive) {
as->isActive = 0;
- gf_node_event_out_str((GF_Node*)as, "isActive");
+ gf_node_event_out((GF_Node*)as, 6/*"isActive"*/);
}
if (stack->stream) {
if (gf_mo_url_changed(stack->stream, &as->url))
return;
}
ac->isActive = 1;
- gf_node_event_out_str((GF_Node *)ac, "isActive");
+ gf_node_event_out((GF_Node *)ac, 7/*"isActive"*/);
gf_mo_set_speed(st->input.stream, st->input.speed);
/*traverse all graph to get parent audio group*/
{
gf_sc_audio_stop(&st->input);
ac->isActive = 0;
- gf_node_event_out_str((GF_Node *)ac, "isActive");
+ gf_node_event_out((GF_Node *)ac, 7/*"isActive"*/);
st->time_handle.needs_unregister = 1;
}
}
if (st->set_duration && st->input.stream) {
ac->duration_changed = gf_mo_get_duration(st->input.stream);
- gf_node_event_out_str(node, "duration_changed");
+ gf_node_event_out(node, 6/*"duration_changed"*/);
st->set_duration = 0;
}
static void audiobuffer_activate(AudioBufferStack *st, M_AudioBuffer *ab)
{
ab->isActive = 1;
- gf_node_event_out_str((GF_Node *)ab, "isActive");
+ gf_node_event_out((GF_Node *)ab, 17/*"isActive"*/);
/*rerender all graph to get parent audio group*/
gf_sc_invalidate(st->output.compositor, NULL);
st->done = 0;
static void audiobuffer_deactivate(AudioBufferStack *st, M_AudioBuffer *ab)
{
ab->isActive = 0;
- gf_node_event_out_str((GF_Node *)ab, "isActive");
+ gf_node_event_out((GF_Node *)ab, 17/*"isActive"*/);
st->time_handle.needs_unregister = 1;
}
{
Bool clear_all = GF_TRUE;
u32 color;
+ Bool is_offscreen = GF_FALSE;
Background2DStack *stack;
if (!ctx || !ctx->drawable || !ctx->drawable->node) return;
stack = (Background2DStack *) gf_node_get_private(ctx->drawable->node);
//in opengl auto mode we still have to clear the canvas
if (!tr_state->immediate_draw && !tr_state->visual->offscreen && tr_state->visual->compositor->hybrid_opengl) {
clear_all = GF_FALSE;
+ is_offscreen = GF_TRUE;
color &= 0x00FFFFFF;
} else
#endif
if (clear_all && !tr_state->visual->offscreen && tr_state->visual->compositor->hybrid_opengl) {
if (ctx->flags & CTX_BACKROUND_NOT_LAYER) {
color &= 0x00FFFFFF;
- compositor_2d_hybgl_clear_surface_ex(tr_state->visual, NULL, color, GF_FALSE);
+ compositor_2d_hybgl_clear_surface(tr_state->visual, NULL, color, GF_FALSE);
clear_all = GF_FALSE;
}
}
) {
/*directly clear with specified color*/
if (clear_all)
- tr_state->visual->ClearSurface(tr_state->visual, &ctx->bi->clip, color);
+ tr_state->visual->ClearSurface(tr_state->visual, &ctx->bi->clip, color, is_offscreen);
} else {
u32 i;
GF_IRect clip;
clip = ctx->bi->clip;
gf_irect_intersect(&clip, &tr_state->visual->to_redraw.list[i].rect);
if (clip.width && clip.height) {
- tr_state->visual->ClearSurface(tr_state->visual, &clip, color);
+ tr_state->visual->ClearSurface(tr_state->visual, &clip, color, is_offscreen);
}
}
}
gf_node_unregister(c3d->background, n);
gf_node_register(btop, n);
c3d->background = btop;
- gf_node_event_out_str(n, "background");
+ gf_node_event_out(n, 5/*"background"*/);
ret = 1;
}
if (force_check || gf_node_dirty_get(c3d->viewpoint)) {
gf_node_unregister(c3d->viewpoint, n);
gf_node_register(btop, n);
c3d->viewpoint = btop;
- gf_node_event_out_str(n, "viewpoint");
+ gf_node_event_out(n, 8/*"viewpoint"*/);
ret = 1;
}
gf_node_unregister(c3d->fog, n);
gf_node_register(btop, n);
c3d->fog = btop;
- gf_node_event_out_str(n, "fog");
+ gf_node_event_out(n, 6/*"fog"*/);
ret = 1;
}
gf_node_unregister(c3d->navigationInfo, n);
gf_node_register(btop, n);
c3d->navigationInfo = btop;
- gf_node_event_out_str(n, "navigationInfo");
+ gf_node_event_out(n, 7/*"navigationInfo"*/);
ret = 1;
}
return ret;
gf_node_unregister(c2d->background, n);
gf_node_register(btop, n);
c2d->background = btop;
- gf_node_event_out_str(n, "background");
+ gf_node_event_out(n, 5/*"background"*/);
ret = 1;
}
gf_node_unregister(c2d->viewport, n);
gf_node_register(btop, n);
c2d->viewport = btop;
- gf_node_event_out_str(n, "viewport");
+ gf_node_event_out(n, 6/*"viewport"*/);
ret = 1;
}
}
if (tr_state->camera->collide_flags & CF_COLLISION) {
col->collideTime = gf_node_get_scene_time(node);
- gf_node_event_out_str(node, "collideTime");
+ gf_node_event_out(node, 5/*"collideTime"*/);
/*if not closer restore*/
if (collide_flags && (last_dist<tr_state->camera->collide_dist)) {
tr_state->camera->collide_flags = collide_flags;
gf_node_unregister(l2d->background, n);
gf_node_register(btop, n);
l2d->background = btop;
- gf_node_event_out_str(n, "background");
+ gf_node_event_out(n, 4/*"background"*/);
}
if (force_traverse) gf_node_traverse(l2d->viewport, tr_state);
btop = (GF_Node*)gf_list_get(tr_state->viewpoints, 0);
gf_node_unregister(l2d->viewport, n);
gf_node_register(btop, n);
l2d->viewport = btop;
- gf_node_event_out_str(n, "viewport");
+ gf_node_event_out(n, 5/*"viewport"*/);
}
}
gf_node_unregister(l3d->background, n);
gf_node_register(btop, n);
l3d->background = btop;
- gf_node_event_out_str(n, "background");
+ gf_node_event_out(n, 4/*"background"*/);
}
if (force_traverse) gf_node_traverse(l3d->viewpoint, tr_state);
btop = (GF_Node*)gf_list_get(tr_state->viewpoints, 0);
gf_node_unregister(l3d->viewpoint, n);
gf_node_register(btop, n);
l3d->viewpoint = btop;
- gf_node_event_out_str(n, "viewpoint");
+ gf_node_event_out(n, 7/*"viewpoint"*/);
}
if (force_traverse) gf_node_traverse(l3d->navigationInfo, tr_state);
btop = (GF_Node*)gf_list_get(tr_state->navigations, 0);
gf_node_unregister(l3d->navigationInfo, n);
gf_node_register(btop, n);
l3d->navigationInfo = btop;
- gf_node_event_out_str(n, "navigationInfo");
+ gf_node_event_out(n, 6/*"navigationInfo"*/);
}
if (force_traverse) gf_node_traverse(l3d->fog, tr_state);
btop = (GF_Node*)gf_list_get(tr_state->fogs, 0);
gf_node_unregister(l3d->fog, n);
gf_node_register(btop, n);
l3d->fog = btop;
- gf_node_event_out_str(n, "fog");
+ gf_node_event_out(n, 5/*"fog"*/);
}
tr_state->traversing_mode = mode;
}
/*for keyboard navigation*/
GF_SensorHandler hdl;
s32 key_scroll;
+ Bool keys_active;
} LayoutStack;
typedef struct
/*set major alignment (X) */
cg = (ChildGroup *)gf_list_get(st->groups, first);
+ if (!cg) continue;
switch (major) {
case L_END:
cg->final.x = st->clip.x + st->clip.width - li->width;
switch (ev->key.key_code) {
case GF_KEY_LEFT:
+ if (!st->keys_active) return 0;
+
if (vertical) return 0;
st->key_scroll = -1;
break;
case GF_KEY_RIGHT:
+ if (!st->keys_active) return 0;
+
if (vertical) return 0;
st->key_scroll = +1;
break;
case GF_KEY_UP:
+ if (!st->keys_active) return 0;
+
if (!vertical) return 0;
st->key_scroll = +1;
break;
case GF_KEY_DOWN:
+ if (!st->keys_active) return 0;
+
if (!vertical) return 0;
st->key_scroll = -1;
break;
+ case GF_KEY_ENTER:
+ st->keys_active = !st->keys_active;
+ break;
default:
st->key_scroll = 0;
return 0;
if (ds->autoOffset) {
ds->offset = ds->rotation_changed;
/*that's an exposedField*/
- if (!is_cancel) gf_node_event_out_str(sh->sensor, "offset");
+ if (!is_cancel) gf_node_event_out(sh->sensor, 4/*"offset"*/);
}
ds->isActive = 0;
- if (!is_cancel) gf_node_event_out_str(sh->sensor, "isActive");
+ if (!is_cancel) gf_node_event_out(sh->sensor, 5/*"isActive"*/);
sh->grabbed = 0;
return is_cancel ? 0 : 1;
} else if (is_mouse) {
gf_mx_copy(stack->initial_matrix, compositor->hit_local_to_world);
stack->start_angle = gf_atan2(compositor->hit_local_point.y, compositor->hit_local_point.x);
ds->isActive = 1;
- gf_node_event_out_str(sh->sensor, "isActive");
+ gf_node_event_out(sh->sensor, 5/*"isActive"*/);
sh->grabbed = 1;
return 1;
}
if (rot > ds->maxAngle) rot = ds->maxAngle;
}
ds->rotation_changed = rot;
- gf_node_event_out_str(sh->sensor, "rotation_changed");
+ gf_node_event_out(sh->sensor, 6/*"rotation_changed"*/);
ds->trackPoint_changed.x = res.x;
ds->trackPoint_changed.y = res.y;
- gf_node_event_out_str(sh->sensor, "trackPoint_changed");
+ gf_node_event_out(sh->sensor, 7/*"trackPoint_changed"*/);
return 1;
}
} else {
if (!ds->isActive && is_over && (ev->type==GF_EVENT_KEYDOWN) && (ev->key.key_code==GF_KEY_ENTER)) {
ds->isActive = 1;
stack->start_angle = ds->offset;
- gf_node_event_out_str(sh->sensor, "isActive");
+ gf_node_event_out(sh->sensor, 5/*"isActive"*/);
return 1;
}
else if (ds->isActive && (ev->type==GF_EVENT_KEYDOWN)) {
}
stack->start_angle = res;
ds->rotation_changed = res;
- gf_node_event_out_str(sh->sensor, "rotation_changed");
+ gf_node_event_out(sh->sensor, 6/*"rotation_changed"*/);
return 1;
}
}
) ) {
if (ps->autoOffset) {
ps->offset = ps->translation_changed;
- if (!is_cancel) gf_node_event_out_str(sh->sensor, "offset");
+ if (!is_cancel) gf_node_event_out(sh->sensor, 4/*"offset"*/);
}
ps->isActive = 0;
- if (!is_cancel) gf_node_event_out_str(sh->sensor, "isActive");
+ if (!is_cancel) gf_node_event_out(sh->sensor, 5/*"isActive"*/);
sh->grabbed = 0;
return is_cancel ? 0 : 1;
} else if (is_mouse) {
stack->start_drag.x = compositor->hit_local_point.x - ps->offset.x;
stack->start_drag.y = compositor->hit_local_point.y - ps->offset.y;
ps->isActive = 1;
- gf_node_event_out_str(sh->sensor, "isActive");
+ gf_node_event_out(sh->sensor, 5/*"isActive"*/);
sh->grabbed = 1;
/*fallthrough to fire mouse coords*/
//return 1;
ps->trackPoint_changed.x = res.x;
ps->trackPoint_changed.y = res.y;
- gf_node_event_out_str(sh->sensor, "trackPoint_changed");
+ gf_node_event_out(sh->sensor, 6/*"trackPoint_changed"*/);
res.x -= stack->start_drag.x;
res.y -= stack->start_drag.y;
}
ps->translation_changed.x = res.x;
ps->translation_changed.y = res.y;
- gf_node_event_out_str(sh->sensor, "translation_changed");
+ gf_node_event_out(sh->sensor, 7/*"translation_changed"*/);
return 1;
}
} else {
if (!ps->isActive && is_over && (ev->type==GF_EVENT_KEYDOWN) && (ev->key.key_code==GF_KEY_ENTER)) {
ps->isActive = 1;
stack->start_drag = ps->offset;
- gf_node_event_out_str(sh->sensor, "isActive");
+ gf_node_event_out(sh->sensor, 5/*"isActive"*/);
return 1;
}
else if (ps->isActive && (ev->type==GF_EVENT_KEYDOWN)) {
if (res.y > ps->maxPosition.y) res.y = ps->maxPosition.y;
}
ps->translation_changed = res;
- gf_node_event_out_str(sh->sensor, "translation_changed");
+ gf_node_event_out(sh->sensor, 7/*"translation_changed"*/);
ps->trackPoint_changed.x = res.x + stack->start_drag.x;
ps->trackPoint_changed.y = res.y + stack->start_drag.y;
- gf_node_event_out_str(sh->sensor, "trackPoint_changed");
+ gf_node_event_out(sh->sensor, 6/*"trackPoint_changed"*/);
stack->start_drag = res;
return 1;
}
if (prox2D_is_in_sensor(stack, ps, compositor->hit_local_point.x, compositor->hit_local_point.y)) {
ps->position_changed.x = compositor->hit_local_point.x;
ps->position_changed.y = compositor->hit_local_point.y;
- gf_node_event_out_str(sh->sensor, "position_changed");
+ gf_node_event_out(sh->sensor, 4/*"position_changed"*/);
if (!ps->isActive) {
ps->isActive = 1;
- gf_node_event_out_str(sh->sensor, "isActive");
+ gf_node_event_out(sh->sensor, 3/*"isActive"*/);
ps->enterTime = stack->last_time;
- gf_node_event_out_str(sh->sensor, "enterTime");
+ gf_node_event_out(sh->sensor, 6/*"enterTime"*/);
}
return 1;
}
/*either we're not over the shape or we're not in sensor*/
if (ps->isActive) {
ps->exitTime = stack->last_time;
- gf_node_event_out_str(sh->sensor, "exitTime");
+ gf_node_event_out(sh->sensor, 7/*"exitTime"*/);
ps->isActive = 0;
- gf_node_event_out_str(sh->sensor, "isActive");
+ gf_node_event_out(sh->sensor, 3/*"isActive"*/);
return 1;
}
return 0;
|| /*keyboard*/ ((ev->type==GF_EVENT_KEYUP) && (ev->key.key_code==GF_KEY_ENTER) )
) {
ts->touchTime = gf_node_get_scene_time(sh->sensor);
- if (!is_cancel) gf_node_event_out_str(sh->sensor, "touchTime");
+ if (!is_cancel) gf_node_event_out(sh->sensor, 6/*"touchTime"*/);
ts->isActive = 0;
- if (!is_cancel) gf_node_event_out_str(sh->sensor, "isActive");
+ if (!is_cancel) gf_node_event_out(sh->sensor, 4/*"isActive"*/);
sh->grabbed = 0;
return is_cancel ? 0 : 1;
}
}
if (is_over != ts->isOver) {
ts->isOver = is_over;
- if (!is_cancel) gf_node_event_out_str(sh->sensor, "isOver");
+ if (!is_cancel) gf_node_event_out(sh->sensor, 5/*"isOver"*/);
return is_cancel ? 0 : 1;
}
if (!ts->isActive && is_over) {
|| /*keyboard*/ ((ev->type==GF_EVENT_KEYDOWN) && (ev->key.key_code==GF_KEY_ENTER))
) {
ts->isActive = 1;
- gf_node_event_out_str(sh->sensor, "isActive");
+ gf_node_event_out(sh->sensor, 4/*"isActive"*/);
sh->grabbed = 1;
return 1;
}
if (ev->type==GF_EVENT_MOUSEUP) return 0;
}
- if (is_over && is_mouse) {
+ if (is_over && is_mouse && (ev->type==GF_EVENT_MOUSEMOVE) ) {
/*THIS IS NOT CONFORMANT, the hitpoint should be in the touchsensor coordinate system, eg we
should store the matrix from TS -> shape and apply that ...*/
ts->hitPoint_changed = compositor->hit_local_point;
- gf_node_event_out_str(sh->sensor, "hitPoint_changed");
+ gf_node_event_out(sh->sensor, 1/*"hitPoint_changed"*/);
ts->hitNormal_changed = compositor->hit_normal;
- gf_node_event_out_str(sh->sensor, "hitNormal_changed");
+ gf_node_event_out(sh->sensor, 2/*"hitNormal_changed"*/);
ts->hitTexCoord_changed = compositor->hit_texcoords;
- gf_node_event_out_str(sh->sensor, "hitTexCoord_changed");
+ gf_node_event_out(sh->sensor, 3/*"hitTexCoord_changed"*/);
return 1;
}
return 0;
if (!ps->isActive) {
ps->isActive = 1;
- gf_node_event_out_str(node, "isActive");
+ gf_node_event_out(node, 3/*"isActive"*/);
ps->enterTime = gf_node_get_scene_time(node);
- gf_node_event_out_str(node, "enterTime");
+ gf_node_event_out(node, 6/*"enterTime"*/);
}
if ((ps->position_changed.x != user_pos.x)
|| (ps->position_changed.y != user_pos.y)
|| (ps->position_changed.z != user_pos.z) )
{
ps->position_changed = user_pos;
- gf_node_event_out_str(node, "position_changed");
+ gf_node_event_out(node, 4/*"position_changed"*/);
}
dist = tr_state->camera->target;
gf_mx_apply_vec(&mx, &dist);
|| (ori.y != ps->orientation_changed.y)
|| (ori.z != ps->orientation_changed.z) ) {
ps->orientation_changed = ori;
- gf_node_event_out_str(node, "orientation_changed");
+ gf_node_event_out(node, 5/*"orientation_changed"*/);
}
} else if (ps->isActive) {
ps->isActive = 0;
- gf_node_event_out_str(node, "isActive");
+ gf_node_event_out(node, 3/*"isActive"*/);
ps->exitTime = gf_node_get_scene_time(node);
- gf_node_event_out_str(node, "exitTime");
+ gf_node_event_out(node, 7/*"exitTime"*/);
}
}
) ) {
if (ps->autoOffset) {
ps->offset = ps->translation_changed;
- if (!is_cancel) gf_node_event_out_str(sh->sensor, "offset");
+ if (!is_cancel) gf_node_event_out(sh->sensor, 4/*"offset"*/);
}
ps->isActive = 0;
- if (!is_cancel) gf_node_event_out_str(sh->sensor, "isActive");
+ if (!is_cancel) gf_node_event_out(sh->sensor, 5/*"isActive"*/);
sh->grabbed = 0;
return is_cancel ? 0 : 1;
}
stack->tracker.normal.z = FIX_ONE;
stack->tracker.d = - gf_vec_dot(stack->start_drag, stack->tracker.normal);
ps->isActive = 1;
- gf_node_event_out_str(sh->sensor, "isActive");
+ gf_node_event_out(sh->sensor, 5/*"isActive"*/);
sh->grabbed = 1;
return 1;
}
gf_mx_apply_ray(&stack->initial_matrix, &loc_ray);
gf_plane_intersect_line(&stack->tracker, &loc_ray.orig, &loc_ray.dir, &res);
ps->trackPoint_changed = res;
- gf_node_event_out_str(sh->sensor, "trackPoint_changed");
+ gf_node_event_out(sh->sensor, 6/*"trackPoint_changed"*/);
gf_vec_diff(res, res, stack->start_drag);
/*clip*/
if (res.y > ps->maxPosition.y) res.y = ps->maxPosition.y;
}
ps->translation_changed = res;
- gf_node_event_out_str(sh->sensor, "translation_changed");
+ gf_node_event_out(sh->sensor, 7/*"translation_changed"*/);
return 1;
}
} else {
if (!ps->isActive && is_over && (ev->type==GF_EVENT_KEYDOWN) && (ev->key.key_code==GF_KEY_ENTER)) {
ps->isActive = 1;
stack->start_drag = ps->offset;
- gf_node_event_out_str(sh->sensor, "isActive");
+ gf_node_event_out(sh->sensor, 5/*"isActive"*/);
return 1;
}
else if (ps->isActive && (ev->type==GF_EVENT_KEYDOWN)) {
}
stack->start_drag = res;
ps->translation_changed = res;
- gf_node_event_out_str(sh->sensor, "translation_changed");
+ gf_node_event_out(sh->sensor, 7/*"translation_changed"*/);
return 1;
}
}
) ) {
if (cs->autoOffset) {
cs->offset = cs->rotation_changed.q;
- if (!is_cancel) gf_node_event_out_str(sh->sensor, "offset");
+ if (!is_cancel) gf_node_event_out(sh->sensor, 5/*"offset"*/);
}
cs->isActive = 0;
- if (!is_cancel) gf_node_event_out_str(sh->sensor, "isActive");
+ if (!is_cancel) gf_node_event_out(sh->sensor, 6/*"isActive"*/);
sh->grabbed = 0;
return is_cancel ? 0 : 1;
}
cs->rotation_changed.z = 0;
cs->isActive = 1;
- gf_node_event_out_str(sh->sensor, "isActive");
+ gf_node_event_out(sh->sensor, 6/*"isActive"*/);
sh->grabbed = 1;
return 1;
}
if (is_over) {
cs->trackPoint_changed = compositor->hit_local_point;
- gf_node_event_out_str(sh->sensor, "trackPoint_changed");
+ gf_node_event_out(sh->sensor, 8/*"trackPoint_changed"*/);
} else {
GF_Plane project_to;
r = compositor->hit_world_ray;
else if (rot > cs->maxAngle) rot = cs->maxAngle;
}
cs->rotation_changed.q = rot;
- gf_node_event_out_str(sh->sensor, "rotation_changed");
+ gf_node_event_out(sh->sensor, 7/*"rotation_changed"*/);
return 1;
}
} else {
cs->rotation_changed.q = cs->offset;
cs->rotation_changed.x = cs->rotation_changed.z = 0;
cs->rotation_changed.y = FIX_ONE;
- gf_node_event_out_str(sh->sensor, "isActive");
+ gf_node_event_out(sh->sensor, 6/*"isActive"*/);
return 1;
}
else if (cs->isActive && (ev->type==GF_EVENT_KEYDOWN)) {
if (res > cs->maxAngle) res = cs->maxAngle;
}
cs->rotation_changed.q = res;
- gf_node_event_out_str(sh->sensor, "rotation_changed");
+ gf_node_event_out(sh->sensor, 7/*"rotation_changed"*/);
return 1;
}
}
) ) {
if (sphere->autoOffset) {
sphere->offset = sphere->rotation_changed;
- if (!is_cancel) gf_node_event_out_str(sh->sensor, "offset");
+ if (!is_cancel) gf_node_event_out(sh->sensor, 2/*"offset"*/);
}
sphere->isActive = 0;
- if (!is_cancel) gf_node_event_out_str(sh->sensor, "isActive");
+ if (!is_cancel) gf_node_event_out(sh->sensor, 3/*"isActive"*/);
sh->grabbed = 0;
return is_cancel ? 0 : 1;
}
st->grab_vec = gf_vec_scale(compositor->hit_local_point, gf_invfix(st->radius));
sphere->isActive = 1;
- gf_node_event_out_str(sh->sensor, "isActive");
+ gf_node_event_out(sh->sensor, 3/*"isActive"*/);
sh->grabbed = 1;
return 1;
}
Fixed cl;
if (is_over) {
sphere->trackPoint_changed = compositor->hit_local_point;
- gf_node_event_out_str(sh->sensor, "trackPoint_changed");
+ gf_node_event_out(sh->sensor, 5/*"trackPoint_changed"*/);
} else {
GF_Ray r;
r = compositor->hit_world_ray;
q1 = gf_quat_multiply(&q1, &q2);
}
sphere->rotation_changed = gf_quat_to_rotation(&q1);
- gf_node_event_out_str(sh->sensor, "rotation_changed");
+ gf_node_event_out(sh->sensor, 4/*"rotation_changed"*/);
return 1;
}
} else {
if (!sphere->isActive && is_over && (ev->type==GF_EVENT_KEYDOWN) && (ev->key.key_code==GF_KEY_ENTER)) {
sphere->isActive = 1;
sphere->rotation_changed = sphere->offset;
- gf_node_event_out_str(sh->sensor, "isActive");
+ gf_node_event_out(sh->sensor, 3/*"isActive"*/);
return 1;
}
else if (sphere->isActive && (ev->type==GF_EVENT_KEYDOWN)) {
return 0;
}
sphere->rotation_changed = res;
- gf_node_event_out_str(sh->sensor, "rotation_changed");
+ gf_node_event_out(sh->sensor, 4/*"rotation_changed"*/);
return 1;
}
}
if (visible && !vs->isActive) {
vs->isActive = 1;
- gf_node_event_out_str(node, "isActive");
+ gf_node_event_out(node, 5/*"isActive"*/);
vs->enterTime = gf_node_get_scene_time(node);
- gf_node_event_out_str(node, "enterTime");
+ gf_node_event_out(node, 3/*"enterTime"*/);
}
else if (!visible && vs->isActive) {
vs->isActive = 0;
- gf_node_event_out_str(node, "isActive");
+ gf_node_event_out(node, 5/*"isActive"*/);
vs->exitTime = gf_node_get_scene_time(node);
- gf_node_event_out_str(node, "exitTime");
+ gf_node_event_out(node, 4/*"exitTime"*/);
}
}
}
if (equal) {
envtest->valueEqual=(equal==1) ? 1 : 0;
- gf_node_event_out_str(node, "valueEqual");
+ gf_node_event_out(node, 6/*"valueEqual"*/);
}
else if (smaller) {
envtest->valueSmaller=1;
- gf_node_event_out_str(node, "valueSmaller");
+ gf_node_event_out(node, 7/*"valueSmaller"*/);
}
else if (larger) {
envtest->valueLarger=1;
- gf_node_event_out_str(node, "valueLarger");
+ gf_node_event_out(node, 5/*"valueLarger"*/);
}
envtest->parameterValue.buffer = gf_strdup(par_value);
- gf_node_event_out_str(node, "parameterValue");
+ gf_node_event_out(node, 8/*"parameterValue"*/);
}
void compositor_evaluate_envtests(GF_Compositor *compositor, u32 param_type)
static void movietexture_activate(MovieTextureStack *stack, M_MovieTexture *mt, Double scene_time)
{
mt->isActive = 1;
- gf_node_event_out_str((GF_Node*)mt, "isActive");
+ gf_node_event_out((GF_Node*)mt, 8/*"isActive"*/);
if (!stack->txh.is_open) {
scene_time -= mt->startTime;
gf_sc_texture_play_from_to(&stack->txh, &mt->url, scene_time, -1, gf_mo_get_loop(stack->txh.stream, mt->loop), 0);
static void movietexture_deactivate(MovieTextureStack *stack, M_MovieTexture *mt)
{
mt->isActive = 0;
- gf_node_event_out_str((GF_Node*)mt, "isActive");
+ gf_node_event_out((GF_Node*)mt, 8/*"isActive"*/);
stack->time_handle.needs_unregister = 1;
if (stack->txh.is_open) {
if (!st->first_frame_fetched && (txh->needs_refresh) ) {
st->first_frame_fetched = 1;
txnode->duration_changed = gf_mo_get_duration(txh->stream);
- gf_node_event_out_str(txh->owner, "duration_changed");
+ gf_node_event_out(txh->owner, 7/*"duration_changed"*/);
/*stop stream if needed*/
if (!txnode->isActive && txh->is_open) {
gf_mo_pause(txh->stream);
tr_state->depth_gain = gf_mulfix(scale, dscale);
#endif
- if (opacity < FIX_ONE) {
+ if (!tr_state->override_appearance && (opacity < FIX_ONE)) {
if (!group->cache) {
group->cache = group_cache_new(tr_state->visual->compositor, node);
group->cache->force_recompute = 1;
txh->owner = owner;
txh->compositor = compositor;
/*insert texture in reverse order, so that textures in sub documents/scenes are updated before parent ones*/
- if (gf_list_find(compositor->textures, txh)<0)
+ if (gf_list_find(compositor->textures, txh)<0) {
gf_list_insert(compositor->textures, txh, 0);
+ compositor->texture_inserted = GF_TRUE;
+ }
if (!txh->update_texture_fcnt) txh->update_texture_fcnt = update_texture_void;
}
BackColor for background nodes
0x00000000 for composite,
compositor clear color otherwise
+ offscreen_clear is set to 1 when the clear targets the canvas buffer in hybrid GL mode
*/
- void (*ClearSurface)(GF_VisualManager *visual, GF_IRect *rc, u32 BackColor);
+ void (*ClearSurface)(GF_VisualManager *visual, GF_IRect *rc, u32 BackColor, Bool offscreen_clear);
/*draws specified texture as flat bitmap*/
Bool (*DrawBitmap)(GF_VisualManager *visual, GF_TraverseState *tr_state, DrawableContext *ctx, GF_ColorKey *col_key);
tr_state->traversing_mode = TRAVERSE_SORT;
ctx->flags &= ~CTX_BACKROUND_NOT_LAYER;
} else {
- visual->ClearSurface(visual, NULL, 0);
+ visual->ClearSurface(visual, NULL, 0, 0);
}
} else
#endif
{
- visual->ClearSurface(visual, NULL, 0);
+ visual->ClearSurface(visual, NULL, 0, 0);
}
return GF_OK;
}
void ra_refresh(GF_RectArray *ra)
{
u32 i, j, k;
+restart:
for (i=0; i<ra->count; i++) {
for (j=i+1; j<ra->count; j++) {
switch (gf_irect_relation(&ra->list[j].rect, &ra->list[i].rect)) {
}
ra->count--;
if (ra->count>=2)
- ra_refresh(ra);
+ goto restart;
return;
default:
break;
ra_refresh(&visual->to_redraw);
if (visual->compositor->debug_defer) {
- visual->ClearSurface(visual, &visual->top_clipper, 0);
+ visual->ClearSurface(visual, &visual->top_clipper, 0, 0);
}
}
if (bck_ctx) {
drawable_check_bounds(bck_ctx, visual);
tr_state->ctx = bck_ctx;
+ tr_state->appear = NULL;
visual->draw_node_index = 0;
/*force clearing entire zone, not just viewport, when using color. If texture, we MUST
if (visual->to_redraw.list[k].opaque_node_index > 0) continue;
#endif
rc = visual->to_redraw.list[k].rect;
- visual->ClearSurface(visual, &rc, 0);
+ visual->ClearSurface(visual, &rc, 0, 0);
}
#ifndef GPAC_DISABLE_3D
if (!count && hyb_force_redraw) {
- compositor_2d_hybgl_clear_surface_ex(tr_state->visual, NULL, 0, GF_FALSE);
+ compositor_2d_hybgl_clear_surface(tr_state->visual, NULL, 0, GF_FALSE);
}
#endif
}
void visual_2d_pick_node(GF_VisualManager *visual, GF_TraverseState *tr_state, GF_Event *ev, GF_ChildNodeItem *children);
-void visual_2d_clear_surface(GF_VisualManager *visual, GF_IRect *rc, u32 BackColor);
+void visual_2d_clear_surface(GF_VisualManager *visual, GF_IRect *rc, u32 BackColor, Bool is_offscreen);
/*gets a drawable context on this visual*/
DrawableContext *visual_2d_get_drawable_context(GF_VisualManager *visual);
}
-void visual_2d_clear_surface(GF_VisualManager *visual, GF_IRect *rc, u32 BackColor)
+void visual_2d_clear_surface(GF_VisualManager *visual, GF_IRect *rc, u32 BackColor, Bool is_offscreen)
{
#ifdef SKIP_DRAW
return;
}
//update a sample data in the media. Note that the sample MUST exists
+GF_EXPORT
GF_Err gf_isom_update_sample(GF_ISOFile *movie, u32 trackNumber, u32 sampleNumber, GF_ISOSample *sample, Bool data_only)
{
GF_Err e;
//update a sample data in the media. Note that the sample MUST exists,
//that sample->data MUST be NULL and sample->dataLength must be NON NULL;
+GF_EXPORT
GF_Err gf_isom_update_sample_reference(GF_ISOFile *movie, u32 trackNumber, u32 sampleNumber, GF_ISOSample *sample, u64 data_offset)
{
GF_Err e;
if (dash->max_width && dash->max_height) {
if ((rep->width>dash->max_width) || (rep->height>dash->max_height)) {
+ GF_LOG(GF_LOG_WARNING, GF_LOG_DASH, ("[DASH] Representation size %dx%d exceeds max display size allowed %dx%d - ignoring\n", rep->width, rep->height, dash->max_width, dash->max_height));
rep->playback.disabled = 1;
continue;
}
}
- if (rep->codecs && dash->max_bit_per_pixel) {
+ if (rep->codecs && (dash->max_bit_per_pixel > 8) ) {
char *vid_type = strstr(rep->codecs, "hvc");
if (!vid_type) vid_type = strstr(rep->codecs, "hev");
if (!vid_type) vid_type = strstr(rep->codecs, "avc");
//Main 10 !!
if (!strncmp(pidc, "2.", 2)) {
rep->playback.disabled = 1;
+ GF_LOG(GF_LOG_WARNING, GF_LOG_DASH, ("[DASH] Representation bit depth higher than max display bit depth - ignoring\n"));
continue;
}
}
//Main 10
if (prof==0x6E) {
rep->playback.disabled = 1;
+ GF_LOG(GF_LOG_WARNING, GF_LOG_DASH, ("[DASH] Representation bit depth higher than max display bit depth - ignoring\n"));
continue;
}
}
char periodID[100];
char xlink[100];
char role[100];
+ u32 nb_rep_descs;
+ char **rep_descs;
+ u32 nb_as_descs;
+ char **as_descs;
+ u32 nb_as_c_descs;
+ char **as_c_descs;
+ u32 nb_p_descs;
+ char **p_descs;
u32 bandwidth;
u32 dependency_bandwidth;
char dependencyID[100];
{
u32 nb_segment;
u64 segment_duration;
-} GF_DASHSementDuration;
+} GF_DASHSegmentDuration;
-static void store_segment_duration(GF_List *segment_duration, u64 SegmentDuration)
+static void store_segment_duration(GF_List **segment_duration, u64 SegmentDuration)
{
u32 k;
- GF_DASHSementDuration *entry;
+ GF_DASHSegmentDuration *entry;
- for (k = 0; k < gf_list_count(segment_duration); k++) {
- entry = (GF_DASHSementDuration *)gf_list_get(segment_duration, k);
+ if (! *segment_duration) *segment_duration = gf_list_new();
+
+ for (k = 0; k < gf_list_count(*segment_duration); k++) {
+ entry = (GF_DASHSegmentDuration *)gf_list_get(*segment_duration, k);
if (SegmentDuration == entry->segment_duration) {
entry->nb_segment++;
return;
}
}
- GF_SAFEALLOC(entry, GF_DASHSementDuration);
+ GF_SAFEALLOC(entry, GF_DASHSegmentDuration);
entry->segment_duration = SegmentDuration;
entry->nb_segment = 1;
- if (!segment_duration) segment_duration = gf_list_new();
- gf_list_add(segment_duration, entry);
+ gf_list_add(*segment_duration, entry);
}
if (next_sap_time) {
u32 scaler;
/*this is the fragment duration from last sample added to next SAP*/
- frag_dur += (u32) (next_sap_time - tf->next_sample_dts - next_dur) * dash_cfg->dash_scale / tf->TimeScale;
+ frag_dur += (s64) (next_sap_time - tf->next_sample_dts - next_dur) * dash_cfg->dash_scale / tf->TimeScale;
/*if media segment about to be produced is longer than max segment length, force segment split*/
if (SegmentDuration + frag_dur > MaxSegmentDuration) {
split_at_rap = GF_TRUE;
if (force_switch_segment || ((SegmentDuration >= MaxSegmentDuration) && (!split_seg_at_rap || next_sample_rap))) {
- store_segment_duration(segment_duration, SegmentDuration);
+ store_segment_duration(&segment_duration, SegmentDuration);
if (mpd_timeline_bs) {
if (previous_segment_duration == SegmentDuration) {
if (!simulation_pass) {
u64 idx_start_range, idx_end_range;
-
gf_isom_close_segment(output, dash_cfg->subsegs_per_sidx, ref_track_id, ref_track_first_dts, tfref ? tfref->media_time_to_pres_time_shift : tf->media_time_to_pres_time_shift, ref_track_next_cts, dash_cfg->daisy_chain_sidx, flush_all_samples ? GF_TRUE : GF_FALSE, dash_cfg->segment_marker_4cc, &idx_start_range, &idx_end_range);
//take care of scalable reps
if (!switch_segment) {
u64 idx_start_range, idx_end_range;
- store_segment_duration(segment_duration, SegmentDuration);
+ store_segment_duration(&segment_duration, SegmentDuration);
/*do not update on last segment, we're likely to have a different last GOP*/
#if 0
u32 most_frequent_duration = 0;
for (k = 0; k < gf_list_count(segment_duration); k++) {
- GF_DASHSementDuration *entry;
- entry = (GF_DASHSementDuration *)gf_list_get(segment_duration, k);
+ GF_DASHSegmentDuration *entry;
+ entry = (GF_DASHSegmentDuration *)gf_list_get(segment_duration, k);
if (entry->nb_segment > most_frequent_duration) {
- max_segment_duration = (Double) ( entry->segment_duration / dash_cfg->dash_scale );
+ max_segment_duration = (Double) entry->segment_duration;
+ max_segment_duration /= dash_cfg->dash_scale;
most_frequent_duration = entry->nb_segment;
}
}
fprintf(dash_cfg->mpd, " dependencyId=\"%s\"", dash_input->dependencyID);
fprintf(dash_cfg->mpd, ">\n");
+ /* writing Representation level descriptors */
+ if (dash_input->nb_rep_descs) {
+ for (i=0; i<dash_input->nb_rep_descs; i++) {
+ fprintf(dash_cfg->mpd, " %s\n", dash_input->rep_descs[i]);
+ }
+ }
+
if (nb_channels && !is_bs_switching)
fprintf(dash_cfg->mpd, " <AudioChannelConfiguration schemeIdUri=\"urn:mpeg:dash:23003:3:audio_channel_configuration:2011\" value=\"%d\"/>\n", nb_channels);
if (mpd_timeline_bs) gf_bs_del(mpd_timeline_bs);
if (segment_duration) {
while (gf_list_count(segment_duration)) {
- GF_DASHSementDuration *entry = (GF_DASHSementDuration *)gf_list_last(segment_duration);
+ GF_DASHSegmentDuration *entry = (GF_DASHSegmentDuration *)gf_list_last(segment_duration);
gf_free(entry);
gf_list_rem_last(segment_duration);
}
set_file = gf_isom_open(dash_inputs[input_idx].file_name, GF_ISOM_OPEN_READ, NULL);
for (i=input_idx+1; i<nb_dash_inputs; i++) {
+ Bool has_same_desc = GF_TRUE;
Bool valid_in_adaptation_set = 1;
Bool assign_to_group = 1;
GF_ISOFile *in;
if (strcmp(dash_inputs[input_idx].role, dash_inputs[i].role))
continue;
+ /* if two inputs don't have the same (number and value) as_desc they don't belong to the same AdaptationSet
+ (use c_as_desc for AdaptationSet descriptors common to all inputs in an AS) */
+ if (dash_inputs[input_idx].nb_as_descs != dash_inputs[i].nb_as_descs)
+ continue;
+ for (j = 0; j < dash_inputs[input_idx].nb_as_descs; j++) {
+ if (strcmp(dash_inputs[input_idx].as_descs[j], dash_inputs[i].as_descs[j])) {
+ has_same_desc= GF_FALSE;
+ break;
+ }
+ }
+ if (!has_same_desc) continue;
+
if (dash_inputs[input_idx].x != dash_inputs[i].x) continue;
if (dash_inputs[input_idx].y != dash_inputs[i].y) continue;
if (dash_inputs[input_idx].w != dash_inputs[i].w) continue;
fprintf(dash_cfg->mpd, " bandwidth=\"%d\"", bandwidth);
fprintf(dash_cfg->mpd, ">\n");
+ /* writing Representation level descriptors */
+ if (dash_input->nb_rep_descs) {
+ for (i=0; i<dash_input->nb_rep_descs; i++) {
+ fprintf(dash_cfg->mpd, " %s\n", dash_input->rep_descs[i]);
+ }
+ }
if (dash_cfg->single_file_mode==1) {
gf_media_mpd_format_segment_name(GF_DASH_TEMPLATE_SEGMENT, 1, SegName, basename, dash_input->representationID, gf_url_get_resource_name(dash_cfg->seg_rad_name), "ts", 0, bandwidth, segment_index, dash_cfg->use_segment_timeline);
/*TODO what should we put for minBufferTime */
fprintf(mpd, "<MPD xmlns=\"urn:mpeg:dash:schema:mpd:2011\" minBufferTime=\"PT%fS\" type=\"%s\"", min_buffer, dash_dynamic ? "dynamic" : "static");
if (dash_dynamic) {
- //we only support profiles for which AST has to be the same
- const char *opt = gf_cfg_get_key(dash_ctx, "DASH", "GenerationNTP");
- sscanf(opt, "%u", &sec);
- sec += ast_shift_sec;
+ if (dash_ctx) {
+ //we only support profiles for which AST has to be the same
+ const char *opt = gf_cfg_get_key(dash_ctx, "DASH", "GenerationNTP");
+ sscanf(opt, "%u", &sec);
+ sec += ast_shift_sec;
+ }
#ifdef _WIN32_WCE
*(LONGLONG *) &filet = (sec - GF_NTP_SEC_1900_TO_1970) * 10000000 + TIMESPEC_TO_FILETIME_OFFSET;
return GF_OK;
}
-static GF_Err write_period_header(FILE *mpd, const char *szID, Double period_start, Double period_duration, Bool dash_dynamic, const char *xlink)
+static GF_Err write_period_header(FILE *mpd, const char *szID, Double period_start, Double period_duration,
+ Bool dash_dynamic, const char *xlink,
+ GF_DashSegInput *dash_inputs, u32 nb_dash_inputs, u32 period_num)
{
u32 h, m;
Double s;
+ u32 i,j;
fprintf(mpd, " <Period");
- if (szID)
+ if (szID && strlen(szID))
fprintf(mpd, " id=\"%s\"", szID);
if (period_start || dash_dynamic) {
fprintf(mpd, " xlink:href=\"%s\"", xlink);
}
fprintf(mpd, ">\n");
+
+ /* writing Period level descriptors */
+ for (i=0; i< nb_dash_inputs; i++) {
+ if (dash_inputs[i].adaptation_set && (dash_inputs[i].period==period_num)) {
+ for (j = 0; j < dash_inputs[i].nb_p_descs; j++) {
+ fprintf(mpd, " %s\n", dash_inputs[i].p_descs[j]);
+ }
+ }
+ }
+
return GF_OK;
}
-static GF_Err write_adaptation_header(FILE *mpd, GF_DashProfile profile, Bool use_url_template, u32 single_file_mode, GF_DashSegInput *first_rep, Bool bitstream_switching_mode, u32 max_width, u32 max_height, char *szMaxFPS, char *szLang, const char *szInitSegment)
+static GF_Err write_adaptation_header(FILE *mpd, GF_DashProfile profile, Bool use_url_template, u32 single_file_mode,
+ GF_DashSegInput *dash_inputs, u32 nb_dash_inputs, u32 period_num, u32 adaptation_set_num, u32 first_rep_in_set,
+ Bool bitstream_switching_mode, u32 max_width, u32 max_height, char *szMaxFPS, char *szLang, const char *szInitSegment)
{
+ u32 i, j;
+ GF_DashSegInput *first_rep = &dash_inputs[first_rep_in_set];
fprintf(mpd, " <AdaptationSet segmentAlignment=\"true\"");
if (bitstream_switching_mode) {
fprintf(mpd, " bitstreamSwitching=\"true\"");
gf_media_reduce_aspect_ratio(&max_width, &max_height);
fprintf(mpd, " par=\"%d:%d\"", max_width, max_height);
}
- if (szLang && szLang[0]) {
+ if (szLang && szLang[0] && strcmp(szLang, "und")) {
fprintf(mpd, " lang=\"%s\"", szLang);
}
/*this should be fixed to use info collected during segmentation process*/
fprintf(mpd, ">\n");
+ /* writing AdaptationSet level descriptors specified only on one input (non discriminating during classification)*/
+ for (i=0; i< nb_dash_inputs; i++) {
+ if (dash_inputs[i].adaptation_set == adaptation_set_num && dash_inputs[i].period == period_num) {
+ for (j = 0; j < dash_inputs[i].nb_as_c_descs; j++) {
+ fprintf(mpd, " %s\n", dash_inputs[i].as_c_descs[j]);
+ }
+ }
+ }
+
if (first_rep) {
- u32 i;
+
+ /* writing AdaptationSet level descriptors specified only all inputs for that AdaptationSet*/
+ for (i=0; i<first_rep->nb_as_descs; i++) {
+ fprintf(mpd, " %s\n", first_rep->as_descs[i]);
+ }
if (bitstream_switching_mode) {
for (i=0; i<first_rep->nb_components; i++) {
}
}
-
if (first_rep->nb_components>1) {
for (i=0; i<first_rep->nb_components; i++) {
struct _dash_component *comp = &first_rep->components[i];
break;
}
/*if lang not specified at adaptationSet level, put it here*/
- if ((!szLang || !szLang[0]) && comp->szLang[0]) {
+ if ((!szLang || !szLang[0]) && (comp->szLang[0] && strcmp(comp->szLang, "und"))) {
fprintf(mpd, " lang=\"%s\"", comp->szLang);
}
fprintf(mpd, "/>\n");
GF_Config *dash_ctx, u32 dash_dynamic, u32 mpd_update_time, u32 time_shift_depth, Double subduration, Double min_buffer,
u32 ast_shift_sec, u32 dash_scale, Bool fragments_in_memory, u32 initial_moof_sn, u64 initial_tfdt, Bool no_fragments_defaults, Bool pssh_moof, Bool samplegroups_in_traf)
{
- u32 i, j, segment_mode;
+ u32 i, j, k, segment_mode;
char *sep, szSegName[GF_MAX_PATH], szSolvedSegName[GF_MAX_PATH], szTempMPD[GF_MAX_PATH], szOpt[GF_MAX_PATH];
char szPeriodXML[GF_MAX_PATH];
const char *opt;
strcpy(dash_inputs[j].xlink, inputs[i].xlink);
if (strlen(dash_inputs[j].xlink)) uses_xlink = GF_TRUE;
strcpy(dash_inputs[j].role, inputs[i].role);
+ dash_inputs[j].nb_rep_descs = inputs[i].nb_rep_descs;
+ dash_inputs[j].rep_descs = (char **)gf_malloc(dash_inputs[j].nb_rep_descs*sizeof(char *));
+ for (k = 0; k < dash_inputs[j].nb_rep_descs; k++) {
+ dash_inputs[j].rep_descs[k] = inputs[i].rep_descs[k];
+ }
+ dash_inputs[j].nb_as_descs = inputs[i].nb_as_descs;
+ dash_inputs[j].as_descs = (char **)gf_malloc(dash_inputs[j].nb_as_descs*sizeof(char *));
+ for (k = 0; k < dash_inputs[j].nb_as_descs; k++) {
+ dash_inputs[j].as_descs[k] = inputs[i].as_descs[k];
+ }
+ dash_inputs[j].nb_as_c_descs = inputs[i].nb_as_c_descs;
+ dash_inputs[j].as_c_descs = (char **)gf_malloc(dash_inputs[j].nb_as_c_descs*sizeof(char *));
+ for (k = 0; k < dash_inputs[j].nb_as_c_descs; k++) {
+ dash_inputs[j].as_c_descs[k] = inputs[i].as_c_descs[k];
+ }
+ dash_inputs[j].nb_p_descs = inputs[i].nb_p_descs;
+ dash_inputs[j].p_descs = (char **)gf_malloc(dash_inputs[j].nb_p_descs*sizeof(char *));
+ for (k = 0; k < dash_inputs[j].nb_p_descs; k++) {
+ dash_inputs[j].p_descs[k] = inputs[i].p_descs[k];
+ }
dash_inputs[j].bandwidth = inputs[i].bandwidth;
if (strlen(inputs[i].role) && strcmp(inputs[i].role, "main"))
const char *id=NULL;
const char *xlink = NULL;
- /*for each identified adaptationSets, write MPD and perform segmentation of input files*/
+ /* Find period information for this period */
for (i=0; i< nb_dash_inputs; i++) {
if (dash_inputs[i].adaptation_set && (dash_inputs[i].period==cur_period+1)) {
period_duration = dash_inputs[i].period_duration;
period_mpd = gf_f64_open(szPeriodXML, "wb");
dash_opts.mpd = period_mpd;
- e = write_period_header(period_mpd, id, 0.0, period_duration, dash_dynamic, NULL);
+ e = write_period_header(period_mpd, id, 0.0, period_duration, dash_dynamic, NULL, dash_inputs, nb_dash_inputs, cur_period+1);
if (e) goto exit;
sprintf(szFPS, "%d", fps_num);
}
- e = write_adaptation_header(period_mpd, dash_profile, use_url_template, segment_mode, &dash_inputs[first_rep_in_set], use_bs_switching, max_width, max_height, szFPS, szLang, szInit);
+ e = write_adaptation_header(period_mpd, dash_profile, use_url_template, segment_mode, dash_inputs, nb_dash_inputs, cur_period+1, cur_adaptation_set+1, first_rep_in_set, use_bs_switching, max_width, max_height, szFPS, szLang, szInit);
if (e) goto exit;
is_first_rep = 1;
fclose(period_mpd);
if (xlink) {
- write_period_header(mpd, id, 0.0, period_duration, dash_dynamic, xlink);
+ write_period_header(mpd, id, 0.0, period_duration, dash_dynamic, xlink, dash_inputs, nb_dash_inputs, cur_period+1);
} else {
dash_insert_period_xml(mpd, szPeriodXML);
}
sprintf(szOpt, "%g", active_period_start);
gf_cfg_set_key(dash_ctx, "DASH", "LastActivePeriodStart", szOpt);
- purge_dash_context(dash_ctx);
+ if (dash_ctx) purge_dash_context(dash_ctx);
}
}
fprintf(mpd, "</MPD>");
}
}
}
+ /* TODO free descriptors */
+ for (i=0; i < nb_dash_inputs; i++) {
+ if (dash_inputs[i].as_descs) gf_free(dash_inputs[i].as_descs);
+ if (dash_inputs[i].as_c_descs) gf_free(dash_inputs[i].as_c_descs);
+ if (dash_inputs[i].p_descs) gf_free(dash_inputs[i].p_descs);
+ if (dash_inputs[i].rep_descs) gf_free(dash_inputs[i].rep_descs);
+ }
gf_free(dash_inputs);
return e;
}
return esd;
}
+
+ if ( (subtype == GF_4CC('j','p','e','g')) || (subtype == GF_4CC('p','n','g',' ')) ) {
+ esd = gf_odf_desc_esd_new(0);
+ esd->slConfig->timestampResolution = gf_isom_get_media_timescale(mp4, track);
+ esd->ESID = gf_isom_get_track_id(mp4, track);
+ esd->OCRESID = esd->ESID;
+ esd->decoderConfig->streamType = GF_STREAM_VISUAL;
+ esd->decoderConfig->objectTypeIndication = (subtype == GF_4CC('j','p','e','g')) ? GPAC_OTI_IMAGE_JPEG : GPAC_OTI_IMAGE_PNG;
+ gf_odf_desc_del((GF_Descriptor*)esd->decoderConfig->decoderSpecificInfo);
+ esd->decoderConfig->decoderSpecificInfo = NULL;
+ return esd;
+ }
+
if (subtype == GF_ISOM_SUBTYPE_3GP_DIMS) {
GF_DIMSDescription dims;
esd = gf_odf_desc_esd_new(0);
GF_BitStream *bs;
GF_Err e;
Bool destroy_esd;
- u32 size, track, di, w, h, dsi_len, mtype;
+ u32 size, track, di, w, h, dsi_len, mtype, id;
GF_ISOSample *samp;
u8 OTI;
char *dsi, *data;
FILE *src;
+ Bool import_mpeg4 = 0;
+ if (import->flags & GF_IMPORT_FORCE_MPEG4) import_mpeg4 = 1;
+ else if (import->esd) import_mpeg4 = 1;
src = gf_f64_open(import->in_name, "rb");
if (!src) return gf_import_message(import, GF_URL_ERROR, "Opening file %s failed", import->in_name);
/*get image size*/
bs = gf_bs_new(data, size, GF_BITSTREAM_READ);
- gf_img_parse(bs, &OTI, &mtype, &w, &h, &dsi, &dsi_len);
+ dsi = NULL;
+ gf_img_parse(bs, &OTI, &mtype, &w, &h, import_mpeg4 ? &dsi : NULL, import_mpeg4 ? &dsi_len : NULL);
gf_bs_del(bs);
if (!OTI) {
e = GF_OK;
destroy_esd = 0;
- if (!import->esd) {
- import->esd = gf_odf_desc_esd_new(2);
- destroy_esd = 1;
- }
- /*update stream type/oti*/
- if (!import->esd->decoderConfig) import->esd->decoderConfig = (GF_DecoderConfig *) gf_odf_desc_new(GF_ODF_DCD_TAG);
- if (!import->esd->slConfig) import->esd->slConfig = (GF_SLConfig *) gf_odf_desc_new(GF_ODF_SLC_TAG);
- import->esd->decoderConfig->streamType = GF_STREAM_VISUAL;
- import->esd->decoderConfig->objectTypeIndication = OTI;
- import->esd->decoderConfig->bufferSizeDB = size;
- import->esd->decoderConfig->avgBitrate = 8*size;
- import->esd->decoderConfig->maxBitrate = 8*size;
- import->esd->slConfig->timestampResolution = 1000;
- if (dsi) {
- if (!import->esd->decoderConfig->decoderSpecificInfo) import->esd->decoderConfig->decoderSpecificInfo = (GF_DefaultDescriptor *) gf_odf_desc_new(GF_ODF_DSI_TAG);
- if (import->esd->decoderConfig->decoderSpecificInfo->data) gf_free(import->esd->decoderConfig->decoderSpecificInfo->data);
- import->esd->decoderConfig->decoderSpecificInfo->data = dsi;
- import->esd->decoderConfig->decoderSpecificInfo->dataLength = dsi_len;
+ id = 0;
+ if (import_mpeg4) {
+
+ if (!import->esd) {
+ import->esd = gf_odf_desc_esd_new(2);
+ destroy_esd = 1;
+ }
+ /*update stream type/oti*/
+ if (!import->esd->decoderConfig) import->esd->decoderConfig = (GF_DecoderConfig *) gf_odf_desc_new(GF_ODF_DCD_TAG);
+ if (!import->esd->slConfig) import->esd->slConfig = (GF_SLConfig *) gf_odf_desc_new(GF_ODF_SLC_TAG);
+ import->esd->decoderConfig->streamType = GF_STREAM_VISUAL;
+ import->esd->decoderConfig->objectTypeIndication = OTI;
+ import->esd->decoderConfig->bufferSizeDB = size;
+ import->esd->decoderConfig->avgBitrate = 8*size;
+ import->esd->decoderConfig->maxBitrate = 8*size;
+ import->esd->slConfig->timestampResolution = 1000;
+
+ if (dsi) {
+ if (!import->esd->decoderConfig->decoderSpecificInfo) import->esd->decoderConfig->decoderSpecificInfo = (GF_DefaultDescriptor *) gf_odf_desc_new(GF_ODF_DSI_TAG);
+ if (import->esd->decoderConfig->decoderSpecificInfo->data) gf_free(import->esd->decoderConfig->decoderSpecificInfo->data);
+ import->esd->decoderConfig->decoderSpecificInfo->data = dsi;
+ import->esd->decoderConfig->decoderSpecificInfo->dataLength = dsi_len;
+ }
+ id = import->esd->ESID;
}
track = 0;
if (mult_desc_allowed)
- track = gf_isom_get_track_by_id(import->dest, import->esd->ESID);
+ track = gf_isom_get_track_by_id(import->dest, id);
if (!track)
- track = gf_isom_new_track(import->dest, import->esd->ESID, GF_ISOM_MEDIA_VISUAL, 1000);
+ track = gf_isom_new_track(import->dest, id, GF_ISOM_MEDIA_VISUAL, 1000);
if (!track) {
e = gf_isom_last_error(import->dest);
goto exit;
}
gf_isom_set_track_enabled(import->dest, track, 1);
- if (!import->esd->ESID) import->esd->ESID = gf_isom_get_track_id(import->dest, track);
- import->final_trackID = import->esd->ESID;
- e = gf_isom_new_mpeg4_description(import->dest, track, import->esd, (import->flags & GF_IMPORT_USE_DATAREF) ? import->in_name : NULL, NULL, &di);
- if (e) goto exit;
+ if (import_mpeg4) {
+ if (!import->esd->ESID) import->esd->ESID = gf_isom_get_track_id(import->dest, track);
+ import->final_trackID = import->esd->ESID;
+
+ e = gf_isom_new_mpeg4_description(import->dest, track, import->esd, (import->flags & GF_IMPORT_USE_DATAREF) ? import->in_name : NULL, NULL, &di);
+ if (e) goto exit;
+ } else {
+ GF_GenericSampleDescription udesc;
+ memset(&udesc, 0, sizeof(GF_GenericSampleDescription));
+ switch (OTI) {
+ case GPAC_OTI_IMAGE_JPEG:
+ udesc.codec_tag = GF_4CC('j', 'p', 'e', 'g');
+ break;
+ case GPAC_OTI_IMAGE_PNG:
+ udesc.codec_tag = GF_4CC('p', 'n', 'g', ' ');
+ break;
+ case GPAC_OTI_IMAGE_JPEG_2000:
+ udesc.codec_tag = GF_4CC('j', 'p', '2', 'k');
+ break;
+ }
+ udesc.width = w;
+ udesc.height = h;
+ udesc.v_res = 72;
+ udesc.h_res = 72;
+ udesc.depth = 24;
+ memcpy(udesc.compressor_name, "\4JPEG", 5);
+
+ gf_isom_new_generic_sample_description(import->dest, track, NULL, NULL, &udesc, &di);
+ import->final_trackID = gf_isom_get_track_id(import->dest, track);
+ }
+
gf_isom_set_visual_info(import->dest, track, di, w, h);
samp = gf_isom_sample_new();
samp->IsRAP = 1;
gf_set_progress("Importing Image", 1, 1);
gf_isom_sample_del(&samp);
+ if (import->duration) {
+ gf_isom_set_last_sample_duration(import->dest, track, import->duration);
+ }
exit:
gf_free(data);
break;
}
}
+
+extern void gf_m2ts_flush_pes(GF_M2TS_Demuxer *ts, GF_M2TS_PES *pes);
+
/* Warning: we start importing only after finding the PMT */
GF_Err gf_import_mpeg_ts(GF_MediaImporter *import)
{
char data[188];
GF_TSImport tsimp;
u64 fsize, done;
- u32 size;
+ u32 size, i;
Bool do_import = 1;
FILE *mts;
char progress[1000];
fclose(mts);
return e;
}
+
+ for (i=0; i<GF_M2TS_MAX_STREAMS; i++) {
+ if (ts->ess[i]) {
+ if (ts->ess[i]->flags & GF_M2TS_ES_IS_PES) {
+ gf_m2ts_flush_pes(ts, (GF_M2TS_PES *) ts->ess[i]);
+ ts->on_event(ts, GF_M2TS_EVT_EOS, (GF_M2TS_PES *) ts->ess[i]);
+ }
+ }
+ }
+
import->esd = NULL;
if (do_import) gf_set_progress(progress, (u32) (fsize/1024), (u32) (fsize/1024));
if (!in) return gf_import_message(import, GF_URL_ERROR, "Opening file %s failed", import->in_name);
bs = gf_bs_from_file(in, GF_BITSTREAM_READ);
- if (!gf_ac3_parser_bs(bs, &hdr, 1)) {
+ if (!gf_ac3_parser_bs(bs, &hdr, GF_TRUE)) {
gf_bs_del(bs);
fclose(in);
return gf_import_message(import, GF_NON_COMPLIANT_BITSTREAM, "Audio isn't AC3 audio");
ts->pcr_pid = pcr_pid;
ts->nb_pck_at_pcr = ts->nb_pck;
- GF_LOG(GF_LOG_INFO, GF_LOG_CONTAINER, ("[MPEG-2 TS] Estimated duration based on instant bitrate: %g\n", ts->duration));
+ GF_LOG(GF_LOG_INFO, GF_LOG_CONTAINER, ("[MPEG-2 TS] Estimated duration based on instant bitrate: %g sec\n", ts->duration));
if (ts->on_event && changed) {
GF_M2TS_PES_PCK pck;
}
if (has_syntax_indicator) {
- /*remove crc32*/
- sec->length -= 4;
- if (gf_m2ts_crc32_check((char *)data, sec->length)) {
- s32 cur_sec_num;
- t->version_number = (data[5] >> 1) & 0x1f;
- if (t->last_section_number && t->section_number && (t->version_number != t->last_version_number)) {
- GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("[MPEG-2 TS] table transmission interrupted: previous table (v=%d) %d/%d sections - new table (v=%d) %d/%d sections\n", t->last_version_number, t->section_number, t->last_section_number, t->version_number, data[6] + 1, data[7] + 1) );
- gf_m2ts_reset_sections(t->sections);
- t->section_number = 0;
- }
+ if (sec->length < 4) {
+ GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("[MPEG-2 TS] corrupted section length %d less than CRC \n", sec->length));
+ } else {
+ /*remove crc32*/
+ sec->length -= 4;
+ if (gf_m2ts_crc32_check((char *)data, sec->length)) {
+ s32 cur_sec_num;
+ t->version_number = (data[5] >> 1) & 0x1f;
+ if (t->last_section_number && t->section_number && (t->version_number != t->last_version_number)) {
+ GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("[MPEG-2 TS] table transmission interrupted: previous table (v=%d) %d/%d sections - new table (v=%d) %d/%d sections\n", t->last_version_number, t->section_number, t->last_section_number, t->version_number, data[6] + 1, data[7] + 1) );
+ gf_m2ts_reset_sections(t->sections);
+ t->section_number = 0;
+ }
- t->current_next_indicator = (data[5] & 0x1) ? 1 : 0;
- /*add one to section numbers to detect if we missed or not the first section in the table*/
- cur_sec_num = data[6] + 1;
- t->last_section_number = data[7] + 1;
- section_start = 8;
- /*we missed something*/
- if (!sec->process_individual && t->section_number + 1 != cur_sec_num) {
- /* TODO - Check how to handle sections when the first complete section does
- not have its sec num 0 */
- section_valid = 0;
- if (t->is_init) {
- GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("[MPEG-2 TS] corrupted table (lost section %d)\n", cur_sec_num ? cur_sec_num-1 : 31) );
+ t->current_next_indicator = (data[5] & 0x1) ? 1 : 0;
+ /*add one to section numbers to detect if we missed or not the first section in the table*/
+ cur_sec_num = data[6] + 1;
+ t->last_section_number = data[7] + 1;
+ section_start = 8;
+ /*we missed something*/
+ if (!sec->process_individual && t->section_number + 1 != cur_sec_num) {
+ /* TODO - Check how to handle sections when the first complete section does
+ not have its sec num 0 */
+ section_valid = 0;
+ if (t->is_init) {
+ GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("[MPEG-2 TS] corrupted table (lost section %d)\n", cur_sec_num ? cur_sec_num-1 : 31) );
+ }
+ } else {
+ section_valid = 1;
+ t->section_number = cur_sec_num;
}
} else {
- section_valid = 1;
- t->section_number = cur_sec_num;
- }
- } else {
- GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("[MPEG-2 TS] corrupted section (CRC32 failed)\n"));
+ GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("[MPEG-2 TS] corrupted section (CRC32 failed)\n"));
+ }
}
} else {
section_valid = 1;
data += len+2;
pos += len+2;
if (desc_len < len+2) {
- GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("[MPEG-2 TS] Invalid PMT es descriptor size for PID %d\n", pes->pid ) );
+ GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("[MPEG-2 TS] Invalid PMT es descriptor size for PID %d\n", es->pid ) );
break;
}
desc_len-=len+2;
ts->on_event(ts, GF_M2TS_EVT_TEMI_TIMECODE, &temi_tc);
}
-static void gf_m2ts_flush_pes(GF_M2TS_Demuxer *ts, GF_M2TS_PES *pes)
+void gf_m2ts_flush_pes(GF_M2TS_Demuxer *ts, GF_M2TS_PES *pes)
{
GF_M2TS_PESHeader pesh;
return GF_OK;
}
+GF_EXPORT
+GF_Err gf_node_list_append_child(GF_ChildNodeItem **list, GF_ChildNodeItem **last_child, GF_Node *n)
+{
+ GF_ChildNodeItem *child, *cur;
+
+ child = *list;
+
+ cur = (GF_ChildNodeItem*) gf_malloc(sizeof(GF_ChildNodeItem));
+ if (!cur) return GF_OUT_OF_MEM;
+ cur->node = n;
+ cur->next = NULL;
+
+ if (!child) {
+ *list = cur;
+ *last_child = cur;
+ } else {
+ if (! *last_child) {
+ while (child->next) {
+ child = child->next;
+ }
+ *last_child = child;
+ }
+ (*last_child)->next = cur;
+ *last_child = cur;
+ }
+ return GF_OK;
+}
+
GF_EXPORT
GF_Node *gf_node_list_get_child(GF_ChildNodeItem *list, s32 pos)
{
pa->value_changed.x += pa->offset.x;
pa->value_changed.y += pa->offset.y;
pa->value_changed.z += pa->offset.z;
- gf_node_event_out_str(node, "value_changed");
+ gf_node_event_out(node, 12/*"value_changed"*/);
}
void PA_Modified(GF_Node *node, GF_FieldInfo *field)
pa->value_changed.x += pa->offset.x;
pa->value_changed.y += pa->offset.y;
- gf_node_event_out_str(node, "value_changed");
+ gf_node_event_out(node, 12/*"value_changed"*/);
}
void PA2D_Modified(GF_Node *node, GF_FieldInfo *field)
}
sa->value_changed += sa->offset;
- gf_node_event_out_str(node, "value_changed");
+ gf_node_event_out(node, 10/*"value_changed"*/);
}
void SA_Modified(GF_Node *node, GF_FieldInfo *field)
{ GF_EVENT_HTML_MSE_REMOVE_SOURCE_BUFFER, "removesourcebuffer", GF_DOM_EVENT_MEDIASOURCE },
/*GPAC internals*/
- { GF_EVENT_SCENE_ATTACHED, "gpac_scene_attached", GF_DOM_EVENT_DOM },
- { GF_EVENT_VP_RESIZE, "gpac_vp_changed", GF_DOM_EVENT_DOM },
+ { GF_EVENT_SCENE_ATTACHED, "gpac_scene_attached", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_VP_RESIZE, "gpac_vp_changed", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_DBLCLICK, "gpac_dbl_click", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_SIZE, "gpac_size_changed", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_SCENE_SIZE, "gpac_scene_size", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_SHOWHIDE, "gpac_show_hide", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_SET_CURSOR, "gpac_set_cursor", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_SET_CAPTION, "gpac_set_caption", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_MOVE, "gpac_move", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_REFRESH, "gpac_move", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_QUIT, "gpac_quit", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_PASTE_TEXT, "gpac_paste", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_COPY_TEXT, "gpac_paste", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_CONNECT, "gpac_on_connect", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_DURATION, "gpac_on_duration", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_EOS, "gpac_eos", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_AUTHORIZATION, "gpac_authorization", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_NAVIGATE, "gpac_navigate", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_NAVIGATE_INFO, "gpac_navigate_info", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_MESSAGE, "gpac_on_message", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_PROGRESS, "gpac_on_progress", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_VIEWPOINTS, "gpac_viewpoints_changed", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_STREAMLIST, "gpac_streamlist_changed", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_METADATA, "gpac_metadata_changed", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_MIGRATE, "gpac_session_migrate", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_DISCONNECT, "gpac_request_disconnect", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_RESOLUTION, "gpac_resolution_changed", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_DROPFILE, "gpac_dropfile", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_TEXT_EDITING_START, "gpac_textedit_start", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_TEXT_EDITING_END, "gpac_textedit_end", GF_DOM_EVENT_GPAC},
+ { GF_EVENT_ADDON_DETECTED, "gpac_addon_found", GF_DOM_EVENT_GPAC}
};
GF_EXPORT
return GF_EVENT_UNKNOWN;
}
+GF_EXPORT
const char *gf_dom_event_get_name(GF_EventType type)
{
u32 i, count;
X_BooleanFilter *bf = (X_BooleanFilter *)n;
if (!bf->set_boolean) {
bf->inputFalse = 1;
- gf_node_event_out_str(n, "inputFalse");
+ gf_node_event_out(n, 1/*"inputFalse"*/);
}
if (bf->set_boolean) {
bf->inputTrue = 1;
- gf_node_event_out_str(n, "inputTrue");
+ gf_node_event_out(n, 3/*"inputTrue"*/);
}
bf->inputNegate = bf->set_boolean ? 0 : 1;
- gf_node_event_out_str(n, "inputNegate");
+ gf_node_event_out(n, 2/*"inputNegate"*/);
}
void InitBooleanFilter(GF_Node *n)
X_BooleanToggle *bt = (X_BooleanToggle *)n;
if (bt->set_boolean) {
bt->toggle = !bt->toggle;
- gf_node_event_out_str(n, "toggle");
+ gf_node_event_out(n, 1/*"toggle"*/);
}
}
void InitBooleanToggle(GF_Node *n)
{
X_BooleanTrigger *bt = (X_BooleanTrigger *)n;
bt->triggerTrue = 1;
- gf_node_event_out_str(n, "triggerTrue");
+ gf_node_event_out(n, 1/*"triggerTrue"*/);
}
void InitBooleanTrigger(GF_Node *n)
{
X_IntegerTrigger *it = (X_IntegerTrigger *)n;
if (it->set_boolean) {
it->triggerValue = it->integerKey;
- gf_node_event_out_str(n, "triggerValue");
+ gf_node_event_out(n, 2/*"triggerValue"*/);
}
}
void InitIntegerTrigger(GF_Node *n)
{
X_TimeTrigger *tt = (X_TimeTrigger *)n;
tt->triggerTime = gf_node_get_scene_time(n);
- gf_node_event_out_str(n, "triggerTime");
+ gf_node_event_out(n, 1/*"triggerTime"*/);
}
void InitTimeTrigger(GF_Node *n)
{
}
}
owner->parent_graph->NodeCallback(owner->parent_graph->userpriv, GF_SG_CALLBACK_INIT, (GF_Node *) proto_node, NULL);
- proto_node->flags |= GF_SG_PROTO_LOADED;
+ proto_node->flags |= GF_SG_PROTO_LOADED | GF_SG_PROTO_HARDCODED;
return;
}
/*not loaded yet*/
}
}
#ifndef GPAC_DISABLE_LOG
- if (gf_log_tool_level_on(GF_LOG_DEBUG, GF_LOG_INTERACT)) {
+ if (gf_log_tool_level_on(GF_LOG_INTERACT, GF_LOG_DEBUG)) {
if (r->IS_route) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_INTERACT, ("[VRML Event] executing %s.%s IS %s.%s", gf_node_get_name(r->FromNode), r->FromField.name, gf_node_get_name(r->ToNode), r->ToField.name));
} else {
break;
}
+#ifndef GPAC_DISABLE_LOG
+ if (gf_log_tool_level_on(GF_LOG_INTERACT, GF_LOG_DEBUG)) {
+ GF_LOG(GF_LOG_DEBUG, GF_LOG_INTERACT, ("[VRML Route] field copy/casted\n"));
+ }
+#endif
+
//if this is a supported eventIn call watcher
if (r->ToField.on_event_in) {
r->ToField.on_event_in(r->ToNode, r);
else
gf_node_event_out(r->ToNode, r->ToField.fieldIndex);
}
+
+#ifndef GPAC_DISABLE_LOG
+ if (gf_log_tool_level_on(GF_LOG_INTERACT, GF_LOG_DEBUG)) {
+ GF_LOG(GF_LOG_DEBUG, GF_LOG_INTERACT, ("[VRML Route] done executing (res %d)\n", ret));
+ }
+#endif
+
return ret;
}
on latest SM, GC will crash if called from a different thread than the thread creating the contex, no clue why
for iOS don't force GC (better performances according to Ivica)
+
+NOTE - this is currently disabled, as performing the GC at each root with complex scenes (lots of objects) really decreases performances
*/
#if !defined(GPAC_IPHONE)
# if (JS_VERSION<180)
-# define FORCE_GC
+//# define FORCE_GC
# endif
#endif
static void JSScript_NodeModified(GF_SceneGraph *sg, GF_Node *node, GF_FieldInfo *info, GF_Node *script);
-Bool JSScriptFromFile(GF_Node *node, const char *opt_file, Bool no_complain);
+Bool JSScriptFromFile(GF_Node *node, const char *opt_file, Bool no_complain, jsval *rval);
void gf_sg_js_call_gc(JSContext *c)
{
gf_sg_lock_javascript(c, 0);
}
-#ifdef FORCE_GC
-void MyJSGC(JSContext *c)
+void do_js_gc(JSContext *c, GF_Node *node)
{
- gf_sg_js_call_gc(c);
+#ifdef FORCE_GC
+ node->sgprivate->scenegraph->trigger_gc = GF_TRUE;
+#endif
+ if (node->sgprivate->scenegraph->trigger_gc) {
+ node->sgprivate->scenegraph->trigger_gc = GF_FALSE;
+ gf_sg_js_call_gc(c);
+ }
}
-#endif
void SFColor_fromHSV(SFColor *col)
char *url;
GF_Node *node = JS_GetContextPrivate(c);
SMJS_ARGS
+ jsval aval;
if (!argc || !JSVAL_IS_STRING(argv[0])) return JS_TRUE;
if ((argc>1) && JSVAL_IS_BOOLEAN(argv[1])) no_complain = (JSVAL_TO_BOOLEAN(argv[1])==JS_TRUE) ? 1 : 0;
url = SMJS_CHARS(c, argv[0]);
if (url) {
- if ( JSScriptFromFile(node, url, no_complain) == 1) {
- SMJS_SET_RVAL( BOOLEAN_TO_JSVAL(JS_TRUE) );
- } else {
- SMJS_SET_RVAL( BOOLEAN_TO_JSVAL(JS_FALSE) );
- }
+ JSScriptFromFile(node, url, no_complain, &aval);
+ SMJS_SET_RVAL(aval);
}
SMJS_FREE(c, url);
return JS_TRUE;
gf_sg_lock_javascript(priv->js_ctx, 0);
-#ifdef FORCE_GC
- MyJSGC(priv->js_ctx);
-#endif
+ do_js_gc(priv->js_ctx, node);
}
static JSBool SMJS_FUNCTION(addRoute)
}
/*field has changed, set routes...*/
if (parent->sgprivate->tag == TAG_ProtoNode) {
+ GF_ProtoInstance *inst = (GF_ProtoInstance *)parent;
gf_sg_proto_propagate_event(parent, field->fieldIndex, (GF_Node*)JS_GetScript(c));
/* Node exposedField can also be routed to another field */
gf_node_event_out_proto(parent, field->fieldIndex);
+
+ //hardcoded protos be implemented in ways not inspecting the node_dirty propagation scheme (eg defining an SFNode in their interface, not linked with the graph).
+ //in this case handle the node as a regular one
+ if (inst->flags & GF_SG_PROTO_HARDCODED) {
+ gf_node_changed_internal(parent, field, 0);
+ }
} else {
gf_node_event_out(parent, field->fieldIndex);
gf_node_changed_internal(parent, field, 0);
}
if (SMJS_ID_IS_INT(id)) {
+ if (! JSVAL_IS_NUMBER(*vp)) {
+ GF_LOG(GF_LOG_ERROR, GF_LOG_SCRIPT, ("[VRML JS] Value is not a number while assigning SFVec2f\n"));
+ return JS_FALSE;
+ }
JS_ValueToNumber(c, *vp, &d);
+
switch (SMJS_ID_TO_INT(id)) {
case 0:
v = FLT2FIX( d);
return JS_TRUE;
}
+ if (! JSVAL_IS_NUMBER(*vp)) {
+ GF_LOG(GF_LOG_ERROR, GF_LOG_SCRIPT, ("[VRML JS] Value is not a number while assigning SFVec3f\n"));
+ return JS_FALSE;
+ }
+
if (SMJS_ID_IS_INT(id) && SMJS_ID_TO_INT(id) >= 0 && SMJS_ID_TO_INT(id) < 3 && JS_ValueToNumber(c, *vp, &d)) {
switch (SMJS_ID_TO_INT(id)) {
case 0:
return JS_TRUE;
}
+ if (! JSVAL_IS_NUMBER(*vp)) {
+ GF_LOG(GF_LOG_ERROR, GF_LOG_SCRIPT, ("[VRML JS] Value is not a number while assigning SFVec3f\n"));
+ return JS_FALSE;
+ }
if (SMJS_ID_IS_INT(id) && SMJS_ID_TO_INT(id) >= 0 && SMJS_ID_TO_INT(id) < 4 && JS_ValueToNumber(c, *vp, &d)) {
switch (SMJS_ID_TO_INT(id)) {
case 0:
return JS_TRUE;
}
+ if (! JSVAL_IS_NUMBER(*vp)) {
+ GF_LOG(GF_LOG_ERROR, GF_LOG_SCRIPT, ("[VRML JS] Value is not a number while assigning SFVec3f\n"));
+ return JS_FALSE;
+ }
if (SMJS_ID_IS_INT(id) && SMJS_ID_TO_INT(id) >= 0 && SMJS_ID_TO_INT(id) < 3 && JS_ValueToNumber(c, *vp, &d)) {
switch (SMJS_ID_TO_INT(id)) {
case 0:
static void setup_js_array(JSContext *c, JSObject *obj, GF_JSField *ptr, uintN argc, jsval *argv)
{
- GF_ScriptPriv *priv = JS_GetScriptStack(c);
+// GF_ScriptPriv *priv = JS_GetScriptStack(c);
ptr->obj = obj;
ptr->js_list = JS_NewArrayObject(c, (jsint) argc, argv);
+/*
gf_js_add_root(c, &ptr->js_list, GF_JSGC_OBJECT);
ptr->is_rooted = 1;
gf_list_add(priv->js_cache, obj);
+*/
}
#define MFARRAY_CONSTRUCTOR(__classp, _fieldType) \
//this could be overloaded for each MF type...
static SMJS_FUNC_PROP_SET(array_setElement)
-u32 ind;
-jsuint len;
-jsdouble d;
-GF_JSField *from;
-JSBool ret;
-GF_JSClass *the_sf_class = NULL;
-JSString *str;
-char *str_val;
-void *sf_slot;
-GF_JSField *ptr = (GF_JSField *) SMJS_GET_PRIVATE(c, obj);
-ind = SMJS_ID_TO_INT(id);
+ u32 ind;
+ jsuint len;
+ jsdouble d;
+ GF_JSField *from;
+ JSBool ret;
+ GF_JSClass *the_sf_class = NULL;
+ JSString *str;
+ char *str_val;
+ void *sf_slot;
+ Bool is_append = 0;
+ GF_JSField *ptr = (GF_JSField *) SMJS_GET_PRIVATE(c, obj);
+ ind = SMJS_ID_TO_INT(id);
-ret = JS_GetArrayLength(c, ptr->js_list, &len);
-if (ret==JS_FALSE) return JS_FALSE;
+ ret = JS_GetArrayLength(c, ptr->js_list, &len);
+ if (ret==JS_FALSE) return JS_FALSE;
-if (gf_sg_vrml_is_sf_field(ptr->field.fieldType)) return JS_FALSE;
+ if (gf_sg_vrml_is_sf_field(ptr->field.fieldType)) return JS_FALSE;
-switch (ptr->field.fieldType) {
-case GF_SG_VRML_MFVEC2F:
- the_sf_class = &js_rt->SFVec2fClass;
- break;
-case GF_SG_VRML_MFVEC3F:
- the_sf_class = &js_rt->SFVec3fClass;
- break;
-case GF_SG_VRML_MFCOLOR:
- the_sf_class = &js_rt->SFColorClass;
- break;
-case GF_SG_VRML_MFROTATION:
- the_sf_class = &js_rt->SFRotationClass;
- break;
-}
-/*dynamic expend*/
-if (ind>=len) {
- ret = JS_SetArrayLength(c, ptr->js_list, len+1);
- if (ret==JS_FALSE) return JS_FALSE;
- while (len<ind) {
- jsval a_val;
- switch (ptr->field.fieldType) {
- case GF_SG_VRML_MFBOOL:
- a_val = BOOLEAN_TO_JSVAL(0);
- break;
- case GF_SG_VRML_MFINT32:
- a_val = INT_TO_JSVAL(0);
- break;
- case GF_SG_VRML_MFFLOAT:
- case GF_SG_VRML_MFTIME:
- a_val = JS_MAKE_DOUBLE(c, 0);
- break;
- case GF_SG_VRML_MFSTRING:
- case GF_SG_VRML_MFURL:
- a_val = STRING_TO_JSVAL( JS_NewStringCopyZ(c, "") );
- break;
- case GF_SG_VRML_MFVEC2F:
- case GF_SG_VRML_MFVEC3F:
- case GF_SG_VRML_MFCOLOR:
- case GF_SG_VRML_MFROTATION:
- a_val = OBJECT_TO_JSVAL( SMJS_CONSTRUCT_OBJECT(c, the_sf_class, obj) );
- break;
- default:
- a_val = INT_TO_JSVAL(0);
- break;
- }
+ switch (ptr->field.fieldType) {
+ case GF_SG_VRML_MFVEC2F:
+ the_sf_class = &js_rt->SFVec2fClass;
+ break;
+ case GF_SG_VRML_MFVEC3F:
+ the_sf_class = &js_rt->SFVec3fClass;
+ break;
+ case GF_SG_VRML_MFCOLOR:
+ the_sf_class = &js_rt->SFColorClass;
+ break;
+ case GF_SG_VRML_MFROTATION:
+ the_sf_class = &js_rt->SFRotationClass;
+ break;
+ }
+ /*dynamic expend*/
+ if (ind>=len) {
+ is_append = 1;
+ ret = JS_SetArrayLength(c, ptr->js_list, len+1);
+ if (ret==JS_FALSE) return JS_FALSE;
+ while (len<ind) {
+ jsval a_val;
+ switch (ptr->field.fieldType) {
+ case GF_SG_VRML_MFBOOL:
+ a_val = BOOLEAN_TO_JSVAL(0);
+ break;
+ case GF_SG_VRML_MFINT32:
+ a_val = INT_TO_JSVAL(0);
+ break;
+ case GF_SG_VRML_MFFLOAT:
+ case GF_SG_VRML_MFTIME:
+ a_val = JS_MAKE_DOUBLE(c, 0);
+ break;
+ case GF_SG_VRML_MFSTRING:
+ case GF_SG_VRML_MFURL:
+ a_val = STRING_TO_JSVAL( JS_NewStringCopyZ(c, "") );
+ break;
+ case GF_SG_VRML_MFVEC2F:
+ case GF_SG_VRML_MFVEC3F:
+ case GF_SG_VRML_MFCOLOR:
+ case GF_SG_VRML_MFROTATION:
+ a_val = OBJECT_TO_JSVAL( SMJS_CONSTRUCT_OBJECT(c, the_sf_class, obj) );
+ break;
+ default:
+ a_val = INT_TO_JSVAL(0);
+ break;
+ }
- if (ptr->field.fieldType!=GF_SG_VRML_MFNODE) {
- gf_sg_vrml_mf_insert(ptr->field.far_ptr, ptr->field.fieldType, &sf_slot, len);
- JS_SetElement(c, ptr->js_list, len, &a_val);
+ if (ptr->field.fieldType!=GF_SG_VRML_MFNODE) {
+ gf_sg_vrml_mf_insert(ptr->field.far_ptr, ptr->field.fieldType, &sf_slot, len);
+ JS_SetElement(c, ptr->js_list, len, &a_val);
+ }
+ len++;
}
- len++;
+ if (ptr->field.far_ptr && (ptr->field.fieldType!=GF_SG_VRML_MFNODE))
+ gf_sg_vrml_mf_insert(ptr->field.far_ptr, ptr->field.fieldType, &sf_slot, ind);
}
- if (ptr->field.far_ptr && (ptr->field.fieldType!=GF_SG_VRML_MFNODE))
- gf_sg_vrml_mf_insert(ptr->field.far_ptr, ptr->field.fieldType, &sf_slot, ind);
-}
-if (ptr->field.far_ptr && (ptr->field.fieldType!=GF_SG_VRML_MFNODE)) {
- u32 items = ((GenMFField *)ptr->field.far_ptr)->count;
- while (ind>=items) {
- gf_sg_vrml_mf_insert(ptr->field.far_ptr, ptr->field.fieldType, &sf_slot, ind);
- items++;
+ if (ptr->field.far_ptr && (ptr->field.fieldType!=GF_SG_VRML_MFNODE)) {
+ u32 items = ((GenMFField *)ptr->field.far_ptr)->count;
+ while (ind>=items) {
+ gf_sg_vrml_mf_insert(ptr->field.far_ptr, ptr->field.fieldType, &sf_slot, ind);
+ items++;
+ }
}
-}
-/*assign object*/
-if (ptr->field.fieldType==GF_SG_VRML_MFNODE) {
- if (JSVAL_IS_VOID(*vp) || JSVAL_IS_NULL(*vp) || !GF_JS_InstanceOf(c, JSVAL_TO_OBJECT(*vp), &js_rt->SFNodeClass, NULL) ) return JS_FALSE;
-} else if (the_sf_class) {
- if (JSVAL_IS_VOID(*vp)) return JS_FALSE;
- if (!GF_JS_InstanceOf(c, JSVAL_TO_OBJECT(*vp), the_sf_class, NULL) ) return JS_FALSE;
-} else if (ptr->field.fieldType==GF_SG_VRML_MFBOOL) {
- if (!JSVAL_IS_BOOLEAN(*vp)) return JS_FALSE;
-} else if (ptr->field.fieldType==GF_SG_VRML_MFINT32) {
- if (!JSVAL_IS_INT(*vp)) return JS_FALSE;
-} else if (ptr->field.fieldType==GF_SG_VRML_MFFLOAT) {
- if (!JSVAL_IS_NUMBER(*vp)) return JS_FALSE;
-} else if (ptr->field.fieldType==GF_SG_VRML_MFTIME) {
- if (!JSVAL_IS_NUMBER(*vp)) return JS_FALSE;
-} else if (ptr->field.fieldType==GF_SG_VRML_MFSTRING) {
- if (!JSVAL_IS_STRING(*vp)) return JS_FALSE;
-} else if (ptr->field.fieldType==GF_SG_VRML_MFURL) {
- if (!JSVAL_IS_STRING(*vp)) return JS_FALSE;
-}
-
-
-/*rewrite MFNode entry*/
-if (ptr->field.fieldType==GF_SG_VRML_MFNODE) {
- GF_Node *prev_n, *new_n;
-
- if (!ptr->owner) return JS_TRUE;
+ /*assign object*/
+ if (ptr->field.fieldType==GF_SG_VRML_MFNODE) {
+ JSObject *o;
+ if (JSVAL_IS_VOID(*vp)) return JS_FALSE;
+ if (JSVAL_IS_NULL(*vp) ) return JS_FALSE;
+ o = JSVAL_TO_OBJECT(*vp);
+ if (!GF_JS_InstanceOf(c, o, &js_rt->SFNodeClass, NULL) ) return JS_FALSE;
+ } else if (the_sf_class) {
+ if (JSVAL_IS_VOID(*vp)) return JS_FALSE;
+ if (!GF_JS_InstanceOf(c, JSVAL_TO_OBJECT(*vp), the_sf_class, NULL) ) return JS_FALSE;
+ } else if (ptr->field.fieldType==GF_SG_VRML_MFBOOL) {
+ if (!JSVAL_IS_BOOLEAN(*vp)) return JS_FALSE;
+ } else if (ptr->field.fieldType==GF_SG_VRML_MFINT32) {
+ if (!JSVAL_IS_INT(*vp)) return JS_FALSE;
+ } else if (ptr->field.fieldType==GF_SG_VRML_MFFLOAT) {
+ if (!JSVAL_IS_NUMBER(*vp)) return JS_FALSE;
+ } else if (ptr->field.fieldType==GF_SG_VRML_MFTIME) {
+ if (!JSVAL_IS_NUMBER(*vp)) return JS_FALSE;
+ } else if (ptr->field.fieldType==GF_SG_VRML_MFSTRING) {
+ if (!JSVAL_IS_STRING(*vp)) return JS_FALSE;
+ } else if (ptr->field.fieldType==GF_SG_VRML_MFURL) {
+ if (!JSVAL_IS_STRING(*vp)) return JS_FALSE;
+ }
+
+
+ /*rewrite MFNode entry*/
+ if (ptr->field.fieldType==GF_SG_VRML_MFNODE) {
+ GF_Node *prev_n, *new_n;
- /*get new node*/
- from = (GF_JSField *) SMJS_GET_PRIVATE(c, JSVAL_TO_OBJECT(*vp));
- new_n = *(GF_Node**)from->field.far_ptr;
+ if (!ptr->owner) return JS_TRUE;
-#if 0
- anobj = node_get_binding(JS_GetScriptStack(c), from->node, 0);
+ /*get new node*/
+ from = (GF_JSField *) SMJS_GET_PRIVATE(c, JSVAL_TO_OBJECT(*vp));
+ new_n = *(GF_Node**)from->field.far_ptr;
+ prev_n = NULL;
- /*add it to the new object if needed*/
- ret = JS_SetElement(c, ptr->js_list, ind, vp);
-#endif
+ if (!is_append) {
+ /*get and delete previous node if any, but unregister later*/
+ prev_n = gf_node_list_del_child_idx( (GF_ChildNodeItem **)ptr->field.far_ptr, ind);
+ }
- /*get and delete previous node if any, but unregister later*/
- prev_n = gf_node_list_del_child_idx( (GF_ChildNodeItem **)ptr->field.far_ptr, ind);
+ if (new_n) {
+ gf_node_list_insert_child( (GF_ChildNodeItem **)ptr->field.far_ptr , new_n, ind);
+ gf_node_register(new_n, ptr->owner);
- if (new_n) {
- gf_node_list_insert_child( (GF_ChildNodeItem **)ptr->field.far_ptr , new_n, ind);
- gf_node_register(new_n, ptr->owner);
+ /*node created from script and inserted in the tree, root it*/
+ if (!from->is_rooted)
+ node_get_binding(JS_GetScriptStack(c), new_n, 0);
+ }
+ /*unregister previous node*/
+ if (prev_n) gf_node_unregister(prev_n, ptr->owner);
- /*node created from script and inserted in the tree, root it*/
- if (!from->is_rooted)
- node_get_binding(JS_GetScriptStack(c), new_n, 0);
+ Script_FieldChanged(c, NULL, ptr, NULL);
+ return JS_TRUE;
}
- /*unregister previous node*/
- if (prev_n) gf_node_unregister(prev_n, ptr->owner);
- Script_FieldChanged(c, NULL, ptr, NULL);
- return JS_TRUE;
-}
+ ret = JS_SetElement(c, ptr->js_list, ind, vp);
+ if (ret==JS_FALSE) return JS_FALSE;
-ret = JS_SetElement(c, ptr->js_list, ind, vp);
-if (ret==JS_FALSE) return JS_FALSE;
+ if (!ptr->owner) return JS_TRUE;
-if (!ptr->owner) return JS_TRUE;
+ /*rewrite MF slot*/
+ switch (ptr->field.fieldType) {
+ case GF_SG_VRML_MFBOOL:
+ ((MFBool *)ptr->field.far_ptr)->vals[ind] = (Bool) JSVAL_TO_BOOLEAN(*vp);
+ break;
+ case GF_SG_VRML_MFINT32:
+ ((MFInt32 *)ptr->field.far_ptr)->vals[ind] = (s32) JSVAL_TO_INT(*vp);
+ break;
+ case GF_SG_VRML_MFFLOAT:
+ JS_ValueToNumber(c, *vp, &d);
+ ((MFFloat *)ptr->field.far_ptr)->vals[ind] = FLT2FIX(d);
+ break;
+ case GF_SG_VRML_MFTIME:
+ JS_ValueToNumber(c, *vp, &d);
+ ((MFTime *)ptr->field.far_ptr)->vals[ind] = d;
+ break;
+ case GF_SG_VRML_MFSTRING:
+ if (((MFString *)ptr->field.far_ptr)->vals[ind]) {
+ gf_free(((MFString *)ptr->field.far_ptr)->vals[ind]);
+ ((MFString *)ptr->field.far_ptr)->vals[ind] = NULL;
+ }
+ str = JSVAL_IS_STRING(*vp) ? JSVAL_TO_STRING(*vp) : JS_ValueToString(c, *vp);
+ str_val = SMJS_CHARS_FROM_STRING(c, str);
+ ((MFString *)ptr->field.far_ptr)->vals[ind] = gf_strdup(str_val);
+ SMJS_FREE(c, str_val);
+ break;
-/*rewrite MF slot*/
-switch (ptr->field.fieldType) {
-case GF_SG_VRML_MFBOOL:
- ((MFBool *)ptr->field.far_ptr)->vals[ind] = (Bool) JSVAL_TO_BOOLEAN(*vp);
- break;
-case GF_SG_VRML_MFINT32:
- ((MFInt32 *)ptr->field.far_ptr)->vals[ind] = (s32) JSVAL_TO_INT(*vp);
- break;
-case GF_SG_VRML_MFFLOAT:
- JS_ValueToNumber(c, *vp, &d);
- ((MFFloat *)ptr->field.far_ptr)->vals[ind] = FLT2FIX(d);
- break;
-case GF_SG_VRML_MFTIME:
- JS_ValueToNumber(c, *vp, &d);
- ((MFTime *)ptr->field.far_ptr)->vals[ind] = d;
- break;
-case GF_SG_VRML_MFSTRING:
- if (((MFString *)ptr->field.far_ptr)->vals[ind]) {
- gf_free(((MFString *)ptr->field.far_ptr)->vals[ind]);
- ((MFString *)ptr->field.far_ptr)->vals[ind] = NULL;
- }
- str = JSVAL_IS_STRING(*vp) ? JSVAL_TO_STRING(*vp) : JS_ValueToString(c, *vp);
- str_val = SMJS_CHARS_FROM_STRING(c, str);
- ((MFString *)ptr->field.far_ptr)->vals[ind] = gf_strdup(str_val);
- SMJS_FREE(c, str_val);
- break;
+ case GF_SG_VRML_MFURL:
+ if (((MFURL *)ptr->field.far_ptr)->vals[ind].url) {
+ gf_free(((MFURL *)ptr->field.far_ptr)->vals[ind].url);
+ ((MFURL *)ptr->field.far_ptr)->vals[ind].url = NULL;
+ }
+ str = JSVAL_IS_STRING(*vp) ? JSVAL_TO_STRING(*vp) : JS_ValueToString(c, *vp);
+ str_val = SMJS_CHARS_FROM_STRING(c, str);
+ ((MFURL *)ptr->field.far_ptr)->vals[ind].url = gf_strdup(str_val);
+ ((MFURL *)ptr->field.far_ptr)->vals[ind].OD_ID = 0;
+ SMJS_FREE(c, str_val);
+ break;
-case GF_SG_VRML_MFURL:
- if (((MFURL *)ptr->field.far_ptr)->vals[ind].url) {
- gf_free(((MFURL *)ptr->field.far_ptr)->vals[ind].url);
- ((MFURL *)ptr->field.far_ptr)->vals[ind].url = NULL;
+ case GF_SG_VRML_MFVEC2F:
+ from = (GF_JSField *) SMJS_GET_PRIVATE(c, JSVAL_TO_OBJECT(*vp));
+ gf_sg_vrml_field_copy(& ((MFVec2f *)ptr->field.far_ptr)->vals[ind], from->field.far_ptr, from->field.fieldType);
+ break;
+ case GF_SG_VRML_MFVEC3F:
+ from = (GF_JSField *) SMJS_GET_PRIVATE(c, JSVAL_TO_OBJECT(*vp));
+ gf_sg_vrml_field_copy(& ((MFVec3f *)ptr->field.far_ptr)->vals[ind], from->field.far_ptr, from->field.fieldType);
+ break;
+ case GF_SG_VRML_MFROTATION:
+ from = (GF_JSField *) SMJS_GET_PRIVATE(c, JSVAL_TO_OBJECT(*vp));
+ gf_sg_vrml_field_copy(& ((MFRotation *)ptr->field.far_ptr)->vals[ind], from->field.far_ptr, from->field.fieldType);
+ break;
+ case GF_SG_VRML_MFCOLOR:
+ from = (GF_JSField *) SMJS_GET_PRIVATE(c, JSVAL_TO_OBJECT(*vp));
+ gf_sg_vrml_field_copy(& ((MFColor *)ptr->field.far_ptr)->vals[ind], from->field.far_ptr, from->field.fieldType);
+ break;
}
- str = JSVAL_IS_STRING(*vp) ? JSVAL_TO_STRING(*vp) : JS_ValueToString(c, *vp);
- str_val = SMJS_CHARS_FROM_STRING(c, str);
- ((MFURL *)ptr->field.far_ptr)->vals[ind].url = gf_strdup(str_val);
- ((MFURL *)ptr->field.far_ptr)->vals[ind].OD_ID = 0;
- SMJS_FREE(c, str_val);
- break;
-
-case GF_SG_VRML_MFVEC2F:
- from = (GF_JSField *) SMJS_GET_PRIVATE(c, JSVAL_TO_OBJECT(*vp));
- gf_sg_vrml_field_copy(& ((MFVec2f *)ptr->field.far_ptr)->vals[ind], from->field.far_ptr, from->field.fieldType);
- break;
-case GF_SG_VRML_MFVEC3F:
- from = (GF_JSField *) SMJS_GET_PRIVATE(c, JSVAL_TO_OBJECT(*vp));
- gf_sg_vrml_field_copy(& ((MFVec3f *)ptr->field.far_ptr)->vals[ind], from->field.far_ptr, from->field.fieldType);
- break;
-case GF_SG_VRML_MFROTATION:
- from = (GF_JSField *) SMJS_GET_PRIVATE(c, JSVAL_TO_OBJECT(*vp));
- gf_sg_vrml_field_copy(& ((MFRotation *)ptr->field.far_ptr)->vals[ind], from->field.far_ptr, from->field.fieldType);
- break;
-case GF_SG_VRML_MFCOLOR:
- from = (GF_JSField *) SMJS_GET_PRIVATE(c, JSVAL_TO_OBJECT(*vp));
- gf_sg_vrml_field_copy(& ((MFColor *)ptr->field.far_ptr)->vals[ind], from->field.far_ptr, from->field.fieldType);
- break;
-}
-Script_FieldChanged(c, NULL, ptr, NULL);
-return JS_TRUE;
+ Script_FieldChanged(c, NULL, ptr, NULL);
+ return JS_TRUE;
}
static SMJS_FUNC_PROP_SET( array_setLength)
-u32 len, i, sftype;
-JSBool ret;
-GF_JSClass *the_sf_class;
-GF_JSField *ptr = (GF_JSField *) SMJS_GET_PRIVATE(c, obj);
-if (!JSVAL_IS_INT(*vp) || JSVAL_TO_INT(*vp) < 0) return JS_FALSE;
+ u32 len, i, sftype;
+ JSBool ret;
+ GF_JSClass *the_sf_class;
+ GF_JSField *ptr = (GF_JSField *) SMJS_GET_PRIVATE(c, obj);
+ if (!JSVAL_IS_INT(*vp) || JSVAL_TO_INT(*vp) < 0) return JS_FALSE;
/*avoids gcc warning*/
#ifndef GPAC_CONFIG_DARWIN
if (!id) id=0;
#endif
-len = JSVAL_TO_INT(*vp);
+ len = JSVAL_TO_INT(*vp);
-if (!len) {
- if (ptr->field.fieldType==GF_SG_VRML_MFNODE) {
- gf_node_unregister_children(ptr->owner, *(GF_ChildNodeItem**)ptr->field.far_ptr);
- *(GF_ChildNodeItem**)ptr->field.far_ptr = NULL;
- } else {
- gf_sg_vrml_mf_reset(ptr->field.far_ptr, ptr->field.fieldType);
+ if (!len) {
+ if (ptr->field.fieldType==GF_SG_VRML_MFNODE) {
+ gf_node_unregister_children(ptr->owner, *(GF_ChildNodeItem**)ptr->field.far_ptr);
+ *(GF_ChildNodeItem**)ptr->field.far_ptr = NULL;
+ } else {
+ gf_sg_vrml_mf_reset(ptr->field.far_ptr, ptr->field.fieldType);
+ }
+ JS_SetArrayLength(c, ptr->js_list, 0);
+ Script_FieldChanged(c, NULL, ptr, NULL);
+ return JS_TRUE;
}
- JS_SetArrayLength(c, ptr->js_list, 0);
- Script_FieldChanged(c, NULL, ptr, NULL);
- return JS_TRUE;
-}
-ret = JS_SetArrayLength(c, ptr->js_list, len);
-if (ret==JS_FALSE) return ret;
+ ret = JS_SetArrayLength(c, ptr->js_list, len);
+ if (ret==JS_FALSE) return ret;
-#if 0
-/*insert till index if needed*/
-if (ptr->field.fieldType != GF_SG_VRML_MFNODE) {
- if (!ptr->field.far_ptr) ptr->field_ptr = ptr->field.far_ptr = gf_sg_vrml_field_pointer_new(ptr->field.fieldType);
- gf_sg_vrml_mf_reset(ptr->field.far_ptr, ptr->field.fieldType);
- gf_sg_vrml_mf_alloc(ptr->field.far_ptr, ptr->field.fieldType, len);
- if (ptr->field_ptr) ptr->field_ptr = ptr->field.far_ptr;
-}
-#endif
-
-the_sf_class = NULL;
-switch (ptr->field.fieldType) {
-case GF_SG_VRML_MFVEC2F:
- the_sf_class = &js_rt->SFVec2fClass;
- break;
-case GF_SG_VRML_MFVEC3F:
- the_sf_class = &js_rt->SFVec3fClass;
- break;
-case GF_SG_VRML_MFCOLOR:
- the_sf_class = &js_rt->SFColorClass;
- break;
-case GF_SG_VRML_MFROTATION:
- the_sf_class = &js_rt->SFRotationClass;
- break;
-case GF_SG_VRML_MFNODE:
-{
- u32 c = gf_node_list_get_count(*(GF_ChildNodeItem**)ptr->field.far_ptr);
- while (len < c) {
- GF_Node *n = gf_node_list_del_child_idx((GF_ChildNodeItem**)ptr->field.far_ptr, c-1);
- if (n) gf_node_unregister(n, ptr->owner);
- c--;
+ the_sf_class = NULL;
+ switch (ptr->field.fieldType) {
+ case GF_SG_VRML_MFVEC2F:
+ the_sf_class = &js_rt->SFVec2fClass;
+ break;
+ case GF_SG_VRML_MFVEC3F:
+ the_sf_class = &js_rt->SFVec3fClass;
+ break;
+ case GF_SG_VRML_MFCOLOR:
+ the_sf_class = &js_rt->SFColorClass;
+ break;
+ case GF_SG_VRML_MFROTATION:
+ the_sf_class = &js_rt->SFRotationClass;
+ break;
+ case GF_SG_VRML_MFNODE:
+ {
+ u32 c = gf_node_list_get_count(*(GF_ChildNodeItem**)ptr->field.far_ptr);
+ while (len < c) {
+ GF_Node *n = gf_node_list_del_child_idx((GF_ChildNodeItem**)ptr->field.far_ptr, c-1);
+ if (n) gf_node_unregister(n, ptr->owner);
+ c--;
+ }
+ if (len>c) {
+ GF_LOG(GF_LOG_ERROR, GF_LOG_SCRIPT, ("[VRML] MFARRAY EXPANSION NOT SUPPORTED!!!\n"));
+ }
}
- if (len>c) {
- GF_LOG(GF_LOG_ERROR, GF_LOG_SCRIPT, ("[VRML] MFARRAY EXPANSION NOT SUPPORTED!!!\n"));
+ return JS_TRUE;
}
-}
-return JS_TRUE;
-}
-sftype = gf_sg_vrml_get_sf_type(ptr->field.fieldType);
-for (i=0; i<len; i++) {
- jsval a_val;
- if (the_sf_class) {
- JSObject *an_obj = SMJS_CONSTRUCT_OBJECT(c, the_sf_class, obj);
- a_val = OBJECT_TO_JSVAL(an_obj );
- } else {
- switch (sftype) {
- case GF_SG_VRML_SFBOOL:
- a_val = BOOLEAN_TO_JSVAL(0);
- break;
- case GF_SG_VRML_SFINT32:
- a_val = INT_TO_JSVAL(0);
- break;
- case GF_SG_VRML_SFFLOAT:
- case GF_SG_VRML_SFTIME:
- a_val = JS_MAKE_DOUBLE(c, 0);
- break;
- case GF_SG_VRML_SFSTRING:
- case GF_SG_VRML_SFURL:
- a_val = STRING_TO_JSVAL( JS_NewStringCopyZ(c, "") );
- break;
- default:
- a_val = INT_TO_JSVAL(0);
- break;
+
+ sftype = gf_sg_vrml_get_sf_type(ptr->field.fieldType);
+ for (i=0; i<len; i++) {
+ jsval a_val;
+ if (the_sf_class) {
+ JSObject *an_obj = SMJS_CONSTRUCT_OBJECT(c, the_sf_class, obj);
+ a_val = OBJECT_TO_JSVAL(an_obj );
+ } else {
+ switch (sftype) {
+ case GF_SG_VRML_SFBOOL:
+ a_val = BOOLEAN_TO_JSVAL(0);
+ break;
+ case GF_SG_VRML_SFINT32:
+ a_val = INT_TO_JSVAL(0);
+ break;
+ case GF_SG_VRML_SFFLOAT:
+ case GF_SG_VRML_SFTIME:
+ a_val = JS_MAKE_DOUBLE(c, 0);
+ break;
+ case GF_SG_VRML_SFSTRING:
+ case GF_SG_VRML_SFURL:
+ a_val = STRING_TO_JSVAL( JS_NewStringCopyZ(c, "") );
+ break;
+ default:
+ a_val = INT_TO_JSVAL(0);
+ break;
+ }
}
+ JS_SetElement(c, ptr->js_list, i, &a_val);
}
- JS_SetElement(c, ptr->js_list, i, &a_val);
-}
-return JS_TRUE;
+ return JS_TRUE;
}
static SMJS_FUNC_PROP_GET( array_getLength)
gf_js_vrml_flush_event_out(node, priv);
-#ifdef FORCE_GC
- MyJSGC(priv->js_ctx);
-#endif
+ do_js_gc(priv->js_ctx, node);
}
-static Bool vrml_js_load_script(M_Script *script, char *file, Bool primary_script)
+static Bool vrml_js_load_script(M_Script *script, char *file, Bool primary_script, jsval *rval)
{
FILE *jsf;
char *jsscript;
u64 fsize;
Bool success = 1;
JSBool ret;
- jsval rval, fval;
+ jsval fval;
GF_ScriptPriv *priv = (GF_ScriptPriv *) script->sgprivate->UserPrivate;
uintN attr;
JSBool found;
fclose(jsf);
jsscript[fsize] = 0;
- ret = JS_EvaluateScript(priv->js_ctx, priv->js_obj, jsscript, (u32) (sizeof(char)*fsize), 0, 0, &rval);
+ *rval = JSVAL_NULL;
+ ret = JS_EvaluateScript(priv->js_ctx, priv->js_obj, jsscript, (u32) (sizeof(char)*fsize), 0, 0, rval);
if (ret==JS_FALSE) success = 0;
if (success && primary_script
&& JS_LookupProperty(priv->js_ctx, priv->js_obj, "initialize", &fval) && !JSVAL_IS_VOID(fval)
&& JS_GetPropertyAttributes(priv->js_ctx, priv->js_obj, "initialize", &attr, &found) && found == JS_TRUE) {
- JS_CallFunctionValue(priv->js_ctx, priv->js_obj, fval, 0, NULL, &rval);
+ JS_CallFunctionValue(priv->js_ctx, priv->js_obj, fval, 0, NULL, rval);
gf_js_vrml_flush_event_out((GF_Node *)script, priv);
}
gf_free(jsscript);
}
/*fetches each listed URL and attempts to load the script - this is SYNCHRONOUS*/
-Bool JSScriptFromFile(GF_Node *node, const char *opt_file, Bool no_complain)
+Bool JSScriptFromFile(GF_Node *node, const char *opt_file, Bool no_complain, jsval *rval)
{
GF_JSAPIParam par;
u32 i;
char *url;
GF_Err e;
const char *ext;
-
M_Script *script = (M_Script *)node;
e = GF_SCRIPT_ERROR;
+ *rval = JSVAL_NULL;
par.dnld_man = NULL;
ScriptAction(NULL, node->sgprivate->scenegraph, GF_JSAPI_OP_GET_DOWNLOAD_MANAGER, NULL, &par);
}
if (!strstr(url, "://") || !strnicmp(url, "file://", 7)) {
- Bool res = vrml_js_load_script(script, url, opt_file ? 0 : 1);
+ Bool res = vrml_js_load_script(script, url, opt_file ? 0 : 1, rval);
gf_free(url);
if (res) return 1;
if (no_complain) return 0;
e = gf_dm_sess_process(sess);
if (e==GF_OK) {
const char *szCache = gf_dm_sess_get_cache_name(sess);
- if (!vrml_js_load_script(script, (char *) szCache, opt_file ? 0 : 1))
+ if (!vrml_js_load_script(script, (char *) szCache, opt_file ? 0 : 1, rval))
e = GF_SCRIPT_ERROR;
}
gf_dm_sess_del(sess);
priv->JS_EventIn = JS_EventIn;
if (!local_script) {
- JSScriptFromFile(node, NULL, 0);
+ JSScriptFromFile(node, NULL, 0, &rval);
gf_sg_lock_javascript(priv->js_ctx, 0);
return;
}
GF_LOG(GF_LOG_DEBUG, GF_LOG_SCRIPT, ("[VRML JS] Evaluating script %s\n", str));
-#if 1
ret = JS_EvaluateScript(priv->js_ctx, priv->js_obj, str, (u32) strlen(str), 0, 0, &rval);
if (ret==JS_TRUE) {
/*call initialize if present*/
JS_CallFunctionValue(priv->js_ctx, priv->js_obj, fval, 0, NULL, &rval);
gf_js_vrml_flush_event_out(node, priv);
}
-#endif
gf_sg_lock_javascript(priv->js_ctx, 0);
-#ifdef FORCE_GC
- MyJSGC(priv->js_ctx);
-#endif
+ do_js_gc(priv->js_ctx, node);
}
static void JSScript_Load(GF_Node *node)
/*deactivate current control*/
if (ctrl && odm->subscene->dyn_ck->mc) {
odm->subscene->dyn_ck->mc->control->enabled = 0;
- gf_node_event_out_str((GF_Node *)odm->subscene->dyn_ck->mc->control, "enabled");
+ gf_node_event_out((GF_Node *)odm->subscene->dyn_ck->mc->control, 7/*"enabled"*/);
}
odm->subscene->dyn_ck->mc = ctrl;
}
/*deactivate current control*/
if (ctrl && ch->clock->mc) {
ch->clock->mc->control->enabled = 0;
- gf_node_event_out_str((GF_Node *)ch->clock->mc->control, "enabled");
+ gf_node_event_out((GF_Node *)ch->clock->mc->control, 7/*"enabled"*/);
}
/*and attach this control to the clock*/
ch->clock->mc = ctrl;
if (st2 == ctrl) continue;
if (st2->control->enabled) {
st2->control->enabled = 0;
- gf_node_event_out_str((GF_Node *) st2->control, "enabled");
+ gf_node_event_out((GF_Node *) st2->control, 7/*"enabled"*/);
}
st2->enabled = 0;
}
gf_list_add(term->net_services_to_remove, service);
}
+ gf_term_lock_media_queue(term, 0);
+
if (!root->parentscene) {
GF_Event evt;
evt.type = GF_EVENT_CONNECT;
gf_scene_remove_object(root->parentscene, root, 0);
gf_odm_disconnect(root, 1);
}
- gf_term_lock_media_queue(term, 0);
return;
}
}
void gf_odm_reset_media_control(GF_ObjectManager *odm, Bool signal_reset)
{
#ifndef GPAC_DISABLE_VRML
- u32 i;
MediaSensorStack *media_sens;
MediaControlStack *media_ctrl;
- i=0;
- while ((media_sens = (MediaSensorStack *)gf_list_enum(odm->ms_stack, &i))) {
+ while ((media_sens = (MediaSensorStack *)gf_list_last(odm->ms_stack))) {
MS_Stop(media_sens);
/*and detach from stream object*/
media_sens->stream = NULL;
+ gf_list_rem_last(odm->ms_stack);
}
- i=0;
- while ((media_ctrl = (MediaControlStack *)gf_list_enum(odm->mc_stack, &i))) {
+ while ((media_ctrl = (MediaControlStack *)gf_list_last(odm->mc_stack))) {
if (signal_reset)
gf_odm_remove_mediacontrol(odm, media_ctrl);
media_ctrl->stream = NULL;
media_ctrl->ck = NULL;
+ gf_list_rem_last(odm->mc_stack);
}
#endif
}
while ((media_sens = (MediaSensorStack *)gf_list_enum(odm->ms_stack, &i)) ) {
if (media_sens && media_sens->sensor->isActive) {
media_sens->sensor->isActive = 0;
- gf_node_event_out_str((GF_Node *) media_sens->sensor, "isActive");
+ gf_node_event_out((GF_Node *) media_sens->sensor, 4/*"isActive"*/);
}
}
#endif
while ((media_sens = (MediaSensorStack *)gf_list_enum(odm->ms_stack, &i)) ) {
if (media_sens && !media_sens->sensor->isActive) {
media_sens->sensor->isActive = 1;
- gf_node_event_out_str((GF_Node *) media_sens->sensor, "isActive");
+ gf_node_event_out((GF_Node *) media_sens->sensor, 4/*"isActive"*/);
}
}
#endif
while ((media_sens = (MediaSensorStack*)gf_list_enum(scene->root_od->ms_stack, &i))) {
if (media_sens->sensor->isActive) {
media_sens->sensor->mediaDuration = dur;
- gf_node_event_out_str((GF_Node *) media_sens->sensor, "mediaDuration");
+ gf_node_event_out((GF_Node *) media_sens->sensor, 3/*"mediaDuration"*/);
}
}
#endif
//we force the timeline of the addon to be locked with the main scene
mo = gf_scene_get_media_object(scene, &url, GF_MEDIA_OBJECT_SCENE, GF_TRUE);
- if (!mo) return;
+ if (!mo || !mo->odm) return;
addon->root_od = mo->odm;
mo->odm->addon = addon;
load_associated_media(scene, addon);
}
}
+ if (!scene->active_addon->root_od) return;
gf_mx_p(scene->active_addon->root_od->mx);
prev_time = (Double) scene->active_addon->media_timestamp;
return 1;
}
+void gf_term_message_ex(GF_Terminal *term, const char *service, const char *message, GF_Err error, Bool no_filtering)
+{
+ GF_Event evt;
+ if (!term || !term->user) return;
+ memset(&evt, 0, sizeof(GF_Event));
+ evt.type = GF_EVENT_MESSAGE;
+ evt.message.service = service;
+ evt.message.message = message;
+ evt.message.error = error;
+
+ if (no_filtering) {
+ if (term->user->EventProc)
+ term->user->EventProc(term->user->opaque, &evt);
+ } else {
+ gf_term_send_event(term, &evt);
+ }
+}
+
+void gf_term_message(GF_Terminal *term, const char *service, const char *message, GF_Err error)
+{
+ gf_term_message_ex(term, service, message, error, 0);
+}
+
static Bool term_script_action(void *opaque, u32 type, GF_Node *n, GF_JSAPIParam *param)
{
Bool ret;
GF_Terminal *term = (GF_Terminal *) opaque;
if (type==GF_JSAPI_OP_MESSAGE) {
- gf_term_message(term, term->root_scene->root_od->net_service->url, param->info.msg, param->info.e);
+ gf_term_message_ex(term, term->root_scene->root_od->net_service->url, param->info.msg, param->info.e, 1);
return 1;
}
if (type==GF_JSAPI_OP_GET_TERM) {
}
-void gf_term_message(GF_Terminal *term, const char *service, const char *message, GF_Err error)
-{
- GF_Event evt;
- if (!term || !term->user) return;
- memset(&evt, 0, sizeof(GF_Event));
- evt.type = GF_EVENT_MESSAGE;
- evt.message.service = service;
- evt.message.message = message;
- evt.message.error = error;
- gf_term_send_event(term, &evt);
-}
GF_EXPORT
GF_Err gf_term_step_clocks(GF_Terminal * term, u32 ms_diff)
u8 *mem_storage;
};
-Bool delete_cache_files(void *cbck, char *item_name, char *item_path) {
+Bool delete_cache_files(void *cbck, char *item_name, char *item_path, GF_FileEnumInfo *file_info) {
const char * startPattern;
int sz;
assert( cbck );
#ifdef GPAC_HAS_SSE2
-static GF_Err gf_color_write_yv12_10_to_yuv_intrin(GF_VideoSurface *vs_dst, unsigned char *pY, unsigned char *pU, unsigned char*pV, u32 src_stride, u32 src_width, u32 src_height, const GF_Window *_src_wnd)
+static GF_Err gf_color_write_yv12_10_to_yuv_intrin(GF_VideoSurface *vs_dst, unsigned char *pY, unsigned char *pU, unsigned char*pV, u32 src_stride, u32 src_width, u32 src_height, const GF_Window *_src_wnd, Bool swap_uv)
{
u32 i, j, w, h;
if (!pU) {
h = src_height;
}
+ if (swap_uv) {
+ u8 *t = pV;
+ pV = pU;
+ pU = t;
+ }
+
+
if (vs_dst->pixel_format == GF_PIXEL_YV12) {
__m128i val1, val2, val_dst, *src1, *src2, *dst;
for (i=0; i<h; i++) {
GF_EXPORT
-GF_Err gf_color_write_yv12_10_to_yuv(GF_VideoSurface *vs_dst, unsigned char *pY, unsigned char *pU, unsigned char*pV, u32 src_stride, u32 src_width, u32 src_height, const GF_Window *_src_wnd)
+GF_Err gf_color_write_yv12_10_to_yuv(GF_VideoSurface *vs_dst, unsigned char *pY, unsigned char *pU, unsigned char*pV, u32 src_stride, u32 src_width, u32 src_height, const GF_Window *_src_wnd, Bool swap_uv)
{
u32 i, j, w, h;
&& (GFINTCAST (pU + src_stride/2)%8 == 0)
&& (GFINTCAST (pV + src_stride/2)%8 == 0)
) {
- return gf_color_write_yv12_10_to_yuv_intrin(vs_dst, pY, pU, pV, src_stride, src_width, src_height, _src_wnd);
+ return gf_color_write_yv12_10_to_yuv_intrin(vs_dst, pY, pU, pV, src_stride, src_width, src_height, _src_wnd, swap_uv);
}
#endif
pU = pU + (src_stride * (_src_wnd->y / 2) + _src_wnd->x) / 2;
pV = pV + (src_stride * (_src_wnd->y / 2) + _src_wnd->x) / 2;
}
+
+ if (swap_uv) {
+ u8 *t = pV;
+ pV = pU;
+ pU = t;
+ }
if (vs_dst->pixel_format == GF_PIXEL_YV12) {
for (i=0; i<h; i++) {
#ifdef GPAC_STATIC_MODULES
-static Bool enum_mod_dir(void *cbck, char *item_name, char *item_path)
+static Bool enum_mod_dir(void *cbck, char *item_name, char *item_path, GF_FileEnumInfo *file_info)
{
if (!strnicmp(item_name, "gm_", 3)) {
printf("Found %s\n", item_name);
return GF_OK;
}
-static Bool delete_dir(void *cbck, char *item_name, char *item_path)
+static Bool delete_dir(void *cbck, char *item_name, char *item_path, GF_FileEnumInfo *file_info)
{
Bool directory_clean_mode = *(Bool*)cbck;
GF_Err gf_enum_directory(const char *dir, Bool enum_directory, gf_enum_dir_item enum_dir_fct, void *cbck, const char *filter)
{
char item_path[GF_MAX_PATH];
+ GF_FileEnumInfo file_info;
#if defined(_WIN32_WCE)
char _path[GF_MAX_PATH];
if (filter && (!strcmp(filter, "*") || !filter[0])) filter=NULL;
+ memset(&file_info, 0, sizeof(GF_FileEnumInfo) );
+
if (!strcmp(dir, "/")) {
#if defined(WIN32) && !defined(_WIN32_WCE)
u32 len;
GetLogicalDriveStrings(len, drives);
len = (u32) strlen(drives);
volume = drives;
+ file_info.directory = GF_TRUE;
+ file_info.drive = GF_TRUE;
while (len) {
- enum_dir_fct(cbck, volume, "");
+ enum_dir_fct(cbck, volume, "", &file_info);
volume += len+1;
len = (u32) strlen(volume);
}
TChar aDrive;
iFs.DriveToChar(i, aDrive);
sprintf(szDrive, "%c:", (TUint)aDrive);
- enum_dir_fct(cbck, szDrive, "");
+ enum_dir_fct(cbck, szDrive, "", &file_info);
}
}
iFs.Close();
#endif
+ memset(&file_info, 0, sizeof(GF_FileEnumInfo) );
+
+
#if defined (_WIN32_WCE)
if (!wcscmp(FindData.cFileName, _T(".") )) goto next;
if (!wcscmp(FindData.cFileName, _T("..") )) goto next;
#endif
#ifdef WIN32
- if (!enum_directory && (FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) goto next;
- if (enum_directory && !(FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) goto next;
+ file_info.directory = (FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? GF_TRUE : GF_FALSE;
+ if (!enum_directory && file_info.directory) goto next;
+ if (enum_directory && !file_info.directory) goto next;
#endif
if (filter) {
#endif
}
+#if defined(WIN32)
+ file_info.hidden = (FindData.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) ? 1 : 0;
+ file_info.system = (FindData.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) ? 1 : 0;
+ file_info.size = MAXDWORD;
+ file_info.size += 1;
+ file_info.size *= FindData.nFileSizeHigh;
+ file_info.size += FindData.nFileSizeLow;
+ file_info.last_modified = (u64) ((*(LONGLONG *) &FindData.ftLastWriteTime - TIMESPEC_TO_FILETIME_OFFSET) / 10000000);
+#endif
+
#if defined (_WIN32_WCE)
CE_WideToChar(FindData.cFileName, file);
strcpy(item_path, _path);
GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("[Core] Checking file %s for enum\n", item_path));
if (stat( item_path, &st ) != 0) goto next;
- if (enum_directory && ( (st.st_mode & S_IFMT) != S_IFDIR)) goto next;
- if (!enum_directory && ((st.st_mode & S_IFMT) == S_IFDIR)) goto next;
+
+ file_info.directory = ((st.st_mode & S_IFMT) == S_IFDIR) ? GF_TRUE : GF_FALSE;
+ if (enum_directory && !file_info.directory) goto next;
+ if (!enum_directory && file_info.directory) goto next;
+
+ file_info.size = st.st_size;
+
+ {
+ struct tm _t = * gmtime(& st.st_mtime);
+ file_info.last_modified = mktime(&_t);
+ }
file = the_file->d_name;
+ if (file && file[0]=='.') file_info.hidden = 1;
+
+ if (file_info.directory) {
+ char * parent_name = strrchr(item_path, '/');
+ if (!parent_name) {
+ file_info.drive = GF_TRUE;
+ } else {
+ struct stat st_parent;
+ parent_name[0] = 0;
+ if (stat(item_path, &st_parent) == 0) {
+ if ((st.st_dev != st_parent.st_dev) || ((st.st_dev == st_parent.st_dev) && (st.st_ino == st_parent.st_ino))) {
+ file_info.drive = GF_TRUE;
+ }
+ }
+ parent_name[0] = '/';
+ }
+ }
#endif
- if (enum_dir_fct(cbck, file, item_path)) {
+ if (enum_dir_fct(cbck, file, item_path, &file_info)) {
#ifdef WIN32
BOOL ret = FindClose(SearchH);
if (!ret) {
}
-Bool enum_modules(void *cbck, char *item_name, char *item_path)
+static Bool enum_modules(void *cbck, char *item_name, char *item_path, GF_FileEnumInfo *file_info)
{
ModuleInstance *inst;
#if CHECK_MODULE
}
-static Bool enum_modules(void *cbck, char *item_name, char *item_path)
+static Bool enum_modules(void *cbck, char *item_name, char *item_path, GF_FileEnumInfo *file_info)
{
ModuleInstance *inst;
-/*
+/*
* GPAC - Multimedia Framework C SDK
*
* Authors: Jean Le Feuvre
projects / gpac.git / commitdiff