开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > PlugIns编程 > 查看源码
plugin-threads.cpp
资源名称：FireFox_Plugin.tar.gz　[点击查看]
上传用户：hongyu5696
上传日期：2018-01-22
资源大小：391k
文件大小：61k
源码类别：

PlugIns编程

开发平台：

Unix_Linux

plugin-threads.cpp：源码内容
  1. #include "plugin.h"
  2. #include <sys/types.h>
  3. #include <sys/stat.h>
  4. #include <sys/time.h>
  5. #include "plugin-setup.h"
  6. #include <fcntl.h>
  7. #include <signal.h>
  8. #include <sys/wait.h>
  9. #include <sys/param.h>
  10. #include <errno.h>
  12. extern int DEBUG;
  13. extern int errno;
  15. static void sig_child(int signo)
  16. {
  17.     wait(NULL);
  18. }
  20. /*
  21.  * Copyright (c) 2002 - 2003
  22.  * NetGroup, Politecnico di Torino (Italy)
  23.  * All rights reserved.
  24.  * 
  25.  * Redistribution and use in source and binary forms, with or without 
  26.  * modification, are permitted provided that the following conditions 
  27.  * are met:
  28.  * 
  29.  * 1. Redistributions of source code must retain the above copyright 
  30.  * notice, this list of conditions and the following disclaimer.
  31.  * 2. Redistributions in binary form must reproduce the above copyright 
  32.  * notice, this list of conditions and the following disclaimer in the 
  33.  * documentation and/or other materials provided with the distribution. 
  34.  * 3. Neither the name of the Politecnico di Torino nor the names of its 
  35.  * contributors may be used to endorse or promote products derived from 
  36.  * this software without specific prior written permission. 
  37.  * 
  38.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
  39.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
  40.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
  41.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
  42.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
  43.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
  44.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
  45.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
  46.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
  47.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
  48.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  49.  * 
  50.  */
  53. /* 
  54.  * the above copyright applies to pthread_suspend only 
  55.  */
  57. #ifdef GTK_ENABLED
  58. gboolean mediacallback(void *data)
  59. {
  60.     nsPluginInstance *instance;
  62.     if (DEBUG > 1)
  63. printf("in mediacallbackn");
  64.     instance = (nsPluginInstance *) data;
  65.     if (instance->mediaCompleteCallback != NULL)
  66. NPN_GetURL(instance->mInstance,
  67.    instance->mediaCompleteCallback, "_self");
  68.     if (instance->mediaCompleteWithErrorCallback != NULL)
  69. NPN_GetURL(instance->mInstance,
  70.    instance->mediaCompleteWithErrorCallback, "_self");
  71.     return FALSE;
  72. }
  73. #endif
  75. void pthread_suspend(int msec)
  76. {
  78.     struct timespec abstime;
  79.     struct timeval now;
  81.     pthread_cond_t cond;
  82.     pthread_mutex_t mutex;
  83.     pthread_mutexattr_t attr;
  85.     pthread_mutexattr_init(&attr);
  86.     pthread_mutex_init(&mutex, &attr);
  87.     pthread_mutex_lock(&mutex);
  89.     pthread_cond_init(&cond, NULL);
  91.     gettimeofday(&now, NULL);
  93.     abstime.tv_sec = now.tv_sec + msec / 1000;
  94.     abstime.tv_nsec = now.tv_usec * 1000 + (msec % 1000) * 1000 * 1000;
  96.     pthread_cond_timedwait(&cond, &mutex, &abstime);
  98.     pthread_mutex_destroy(&mutex);
  99.     pthread_cond_destroy(&cond);
  101. }
  103. //this function must be called with control_mutex locked
  104. void launchPlayerThread(nsPluginInstance * instance)
  105. {
  106.     void *thread_return;
  108.     if (DEBUG)
  109. printf("In launchPlayerThread, state = %dn", instance->state);
  111.     if (instance->threadlaunched == 1) {
  112. if (DEBUG)
  113.     printf("launchPlayerThread - joining threadn");
  114. pthread_join(instance->player_thread, &thread_return);
  115.     }
  116.     if (instance->js_state == JS_STATE_UNDEFINED) {
  117. if (DEBUG)
  118.     printf("launchPlayerThread - creating new threadn");
  119. pthread_create(&(instance->player_thread),
  120.        &(instance->thread_attr), playPlaylist,
  121.        (void *) (instance->td));
  122. instance->js_state = JS_STATE_INITIALIZING;
  123. instance->threadlaunched = 1;
  124. instance->threadsignaled = 0;
  125.     } else {
  126. printf
  127.     ("****WARNING: launching duplicate player thread, js_state = %dn",
  128.      instance->js_state);
  129. instance->threadlaunched = 0;
  130.     }
  131. }
  133. void signalPlayerThread(nsPluginInstance * instance)
  134. {
  135.     //signal the player thread
  136.     if (DEBUG) {
  137. printf("Signalling Player thread, state = %d, js_state = %dn",
  138.        instance->state, instance->js_state);
  139.     }
  141.     if (instance->threadlaunched != 1)
  142. if (DEBUG)
  143.     printf("****Player thread did not launch correctly****n");
  145.     pthread_mutex_lock(&(instance->control_mutex));
  146.     while (instance->js_state == JS_STATE_INITIALIZING) {
  147. if (DEBUG)
  148.     printf("Waiting for player thread to start....%in",
  149.    instance->js_state);
  150. pthread_mutex_unlock(&(instance->control_mutex));
  151. pthread_suspend(10);
  152. pthread_mutex_lock(&(instance->control_mutex));
  153.     }
  154.     if (instance->js_state == JS_STATE_BUFFERING
  155. || instance->js_state == JS_STATE_READY) {
  156. pthread_mutex_lock(&(instance->playlist_cond_mutex));
  157. pthread_cond_signal(&(instance->playlist_complete_cond));
  158. pthread_mutex_unlock(&(instance->playlist_cond_mutex));
  159. instance->threadsignaled = 1;
  160.     } else {
  161. if (DEBUG)
  162.     printf("****Player thread did not start correctly****n");
  163.     }
  164.     pthread_mutex_unlock(&(instance->control_mutex));
  165. }
  167. FILE *mypopen(char **argv, pid_t * pid, int *control,
  168.       nsPluginInstance * instance)
  169. {
  170.     int filedesr[2], filedesw[2], err;
  171.     pid_t child;
  172.     long flags;
  173.     sigset_t newmask;
  174.     FILE *retfd;
  176.     pipe(filedesr);
  177.     pipe(filedesw);
  178.     child = fork();
  180.     if (!child) {
  181. if (DEBUG) {
  182.     char **tmp;
  183.     tmp = argv;
  184.     printf("Starting: ");
  185.     while (*tmp)
  186. printf("%s ", *(tmp++));
  187.     printf("n");
  188. }
  190. dup2(filedesw[0], 0);
  191. dup2(filedesr[1], 1);
  192. dup2(filedesr[1], 2);
  193. close(filedesw[1]);
  194. close(filedesr[0]);
  195. setsid();
  196. setpgid(0, 0);
  197. sigemptyset(&newmask);
  198. sigaddset(&newmask, SIGTERM);
  199. sigaddset(&newmask, SIGKILL);
  200. pthread_sigmask(SIG_UNBLOCK, &newmask, 0L);
  201. usleep(500);
  202. if (execvp(argv[0], argv) < 0) {
  203.     err = errno;
  204. #ifdef GTK_ENABLED
  205.     snprintf(instance->lastmessage, 1024, "Error: %i - %s", err,
  206.      strerror(err));
  207.     g_idle_add(gtkgui_message, instance);
  208. #endif
  209.     perror("execv");
  211. }
  212. _exit(0);
  214.     } else {
  215. // setup signal handler for child
  216. signal(SIGCHLD, sig_child);
  217. sigemptyset(&newmask);
  218. sigaddset(&newmask, SIGCHLD);
  219. sigaddset(&newmask, SIGTERM);
  220. sigaddset(&newmask, SIGKILL);
  221. pthread_sigmask(SIG_UNBLOCK, &newmask, 0L);
  223. *pid = child;
  224. *control = filedesw[1];
  225. close(filedesw[0]);
  226. close(filedesr[1]);
  228. // make the operations on the control pipe non-blocking
  229. flags = fcntl(*control, F_GETFL, 0);
  230. flags |= O_NONBLOCK;
  231. #ifndef BSD
  232. flags |= O_NDELAY;
  233. #endif
  234. fcntl(*control, F_SETFL, flags);
  236. retfd = fdopen(filedesr[0], "r");
  238. return retfd;
  239.     }
  240. }
  243. void SetupPlayer(nsPluginInstance * instance, XEvent * event)
  244. {
  245.     int i;
  246.     char xval[32], yval[32];
  247.     char *filename;
  248.     char *baseurl;
  249.     char buffer[1024];
  250. #ifndef X_DISPLAY_MISSING
  251.     char *dispName = XDisplayName(NULL);
  252. #endif
  253.     bool isRemoteDisplay = false;
  255.     if (instance->threadsetup == 1)
  256. return;
  257.     if (instance->toolkitok != 0)
  258. return;
  259.     instance->td->w = instance->widget;
  260.     instance->td->instance = instance;
  262.     if (DEBUG > 1)
  263. printf("Entering SetupPlayern");
  265. #ifdef X_ENABLED
  266.     DrawUI(instance->widget, instance, _("Loading Media..."), 0, -1);
  267. #endif
  268. #ifdef GTK_ENABLED
  269.     if (instance->status != NULL)
  270. gtk_label_set_text(instance->status, _("Loading Media..."));
  271. #endif
  273.     if (instance->td->list == NULL) {
  274. instance->td->list = instance->list;
  275.     }
  277. /*
  278.     if (instance->href) {
  279. if (DEBUG)
  280.     printf("using href for urln");
  281. snprintf(instance->td->list->url, 1024, "%s", instance->href);
  282.     } else 
  283. */
  284.     if (instance->fname) {
  285. if (DEBUG)
  286.     printf("using fname for urln");
  287. snprintf(instance->td->list->url, 1024, "%s", instance->fname);
  288.     } else {
  289. if (DEBUG)
  290.     printf("using url for urln");
  291. snprintf(instance->td->list->url, 1024, "%s", instance->url);
  292.     }
  294.     if ((instance->fname == NULL) && (instance->url == NULL)) {
  295. if (DEBUG)
  296.     printf("using href for urln");
  297. snprintf(instance->td->list->url, 1024, "%s", instance->href);
  298.     }
  300.     if (instance->mode == NP_FULL) {
  301. snprintf(xval, 32, "%i", instance->window_width);
  302. snprintf(yval, 32, "%i", instance->window_height);
  303.     } else {
  304. snprintf(xval, 32, "%i", instance->embed_width);
  305. if (instance->maintain_aspect == 0 && instance->showcontrols == 1) {
  306.     snprintf(yval, 32, "%i", instance->embed_height - 16);
  307. } else {
  308.     snprintf(yval, 32, "%i", instance->embed_height);
  309. }
  311.     }
  313.     baseurl = NULL;
  314.     if (instance->baseurl == NULL) {
  315. baseurl = getURLBase(instance->td->list->url);
  317. if (baseurl != NULL) {
  318.     if (instance->baseurl == NULL) {
  319. instance->baseurl = baseurl;
  320.     } else {
  321. if (strcmp(instance->baseurl, baseurl) != 0) {
  322.     NPN_MemFree(instance->baseurl);
  323.     instance->baseurl = baseurl;
  324. } else {
  325.     NPN_MemFree(baseurl);
  326. }
  327.     }
  328. }
  329.     }
  331.     if (instance->hostname == NULL)
  332. instance->hostname = getURLHostname(instance->td->list->url);
  334.     if (instance->keep_download == 1) {
  335. instance->td->list->remove = 0;
  336. filename = getURLFilename(instance->td->list->url);
  337. snprintf(instance->td->list->fname, 1024, "%s/%s",
  338.  instance->download_dir, filename);
  339. if (filename)
  340.     NPN_MemFree(filename);
  341.     } else {
  342. if ((instance->nomediacache == 0)
  343.     && (instance->td->list->bytes > 0)) {
  344.     if (strlen(instance->td->list->fname) == 0) {
  345. snprintf(instance->td->list->fname, 1024, "%s",
  346.  tempnam("/tmp", "downloadplug-inXXXXXX"));
  347.     }
  348. } else {
  349.     // fix up the URL
  350.     pthread_mutex_lock(&(instance->playlist_mutex));
  351.     fullyQualifyURL(instance, instance->td->list->url, buffer);
  352.     if (DEBUG)
  353. printf("url %snbuffer %sn", instance->td->list->url,
  354.        buffer);
  355.     snprintf(instance->td->list->url, 1024, "%s", buffer);
  356.     pthread_mutex_unlock(&(instance->playlist_mutex));
  357. }
  358.     }
  360.     // set up the vars
  361.     i = 0;
  362.     while (i < 50) {
  363. instance->td->argv[i++] = NULL;
  364.     }
  366.     i = 0;
  367.     snprintf(buffer, 1024, "download");
  368.     instance->td->argv[i++] = strdup(buffer);
  369.     if (instance->novop == 1) {
  370. snprintf(buffer, 1024, "-vop");
  371. instance->td->argv[i++] = strdup(buffer);
  372. snprintf(buffer, 1024, "null");
  373. instance->td->argv[i++] = strdup(buffer);
  374.     } else {
  375. if (instance->vop != NULL) {
  376.     snprintf(buffer, 1024, "-vop");
  377.     instance->td->argv[i++] = strdup(buffer);
  378.     snprintf(buffer, 1024, "%s", instance->vop);
  379.     instance->td->argv[i++] = strdup(buffer);
  380.     if (strncmp(instance->vop, "scale=", 6) == 0) {
  381. snprintf(buffer, 1024, "-fs");
  382. instance->td->argv[i++] = strdup(buffer);
  383.     }
  384. }
  385.     }
  387.     if ((instance->mode == NP_EMBED) && (instance->noembed == 0)) {
  388. if (instance->window != 0) {
  389.     snprintf(buffer, 1024, "-wid");
  390.     instance->td->argv[i++] = strdup(buffer);
  391. #ifdef X_ENABLED
  392. //          instance->player_window =
  393. //              XCreateSimpleWindow(instance->display, instance->window, 0,
  394. //                                  0, instance->embed_width,
  395. //                                  instance->embed_height, 0, 0, 0);
  396.     snprintf(buffer, 1024, "0x%x", (int) instance->window);
  397.     instance->td->argv[i++] = strdup(buffer);
  398. #endif
  399. #ifdef GTK_ENABLED
  400.     if (instance->targetplayer == 1) {
  401. gtk_widget_show(instance->gtkwidget);
  402. gtk_widget_show(instance->drawing_area);
  403.     }
  404. #ifdef GTK2_ENABLED
  405.     instance->player_window =
  406. gtk_socket_get_id(GTK_SOCKET(instance->drawing_area));
  407. #endif
  408. #ifdef GTK1_ENABLED
  409.     instance->player_window =
  410. GDK_WINDOW_XWINDOW(instance->drawing_area->window);
  411. #endif /* if (instance->targetplayer == 1) */
  412.     snprintf(buffer, 1024, "0x%x", (int) instance->player_window);
  413.     instance->td->argv[i++] = strdup(buffer);
  414. #ifdef GTK2_ENABLED
  415.     instance->visible_signal_id =
  416. g_signal_connect_after(G_OBJECT(instance->gtkwidget),
  417.        "visibility-notify-event",
  418.        G_CALLBACK(window_visible),
  419.        instance);
  420. #endif
  421.     if (instance->targetplayer == 1)
  422. gtk_widget_hide(instance->gtkwidget);
  424. #endif
  425. } else {
  426.     instance->player_window = 0;
  427. }
  428.     }
  430.     if ((instance->mode == NP_FULL) && (instance->noembed == 0)) {
  431. if (instance->window != 0) {
  432.     snprintf(buffer, 1024, "-wid");
  433.     instance->td->argv[i++] = strdup(buffer);
  434. #ifdef X_ENABLED
  435.     snprintf(buffer, 1024, "0x%x", (int) instance->window);
  436.     instance->td->argv[i++] = strdup(buffer);
  437. #endif
  438. #ifdef GTK_ENABLED
  439.     gtk_widget_set_usize(GTK_WIDGET(instance->status),
  440.  instance->window_width - 20, 19);
  441. #ifdef GTK2_ENABLED
  442.     instance->player_window =
  443. gtk_socket_get_id(GTK_SOCKET(instance->drawing_area));
  444. #endif
  445. #ifdef GTK1_ENABLED
  446.     instance->player_window =
  447. GDK_WINDOW_XWINDOW(instance->drawing_area->window);
  448. #endif
  449.     snprintf(buffer, 1024, "0x%x", (int) instance->player_window);
  450.     instance->td->argv[i++] = strdup(buffer);
  451. #endif
  452. } else {
  453.     instance->player_window = 0;
  454. }
  455.     }
  457.     if ((instance->embed_width == 0)
  458. || (instance->noembed == 1)) {
  459. // do nothing
  460.     } else {
  461. if (instance->mode == NP_EMBED) {
  462. #ifndef X_DISPLAY_MISSING
  463.     // on remote display, XShm will be disabled.
  464.     // it should not specified aspect. 
  465.     if (dispName) {
  466. if (strncmp(dispName, "unix:", 5) == 0)
  467.     dispName += 4;
  468. else if (strncmp(dispName, "localhost:", 10) == 0)
  469.     dispName += 9;
  470. if (*dispName != ':' || atoi(dispName + 1) >= 10) {
  471.     isRemoteDisplay = true;
  472.     instance->maintain_aspect = 0;
  473.     if (DEBUG)
  474. printf("x11 is running on remote display.n");
  475. }
  476.     }
  477. #endif
  478.     if ((isRemoteDisplay == false)
  479. && (instance->targetplayer == 0)) {
  480. if (instance->maintain_aspect == 1) {
  481.     snprintf(buffer, 1024, "-vf");
  482.     instance->td->argv[i++] = strdup(buffer);
  483.     snprintf(buffer, 1024, "scale=%s:-3", xval);
  484.     instance->td->argv[i++] = strdup(buffer);
  485. } else {
  486.     snprintf(buffer, 1024, "-x");
  487.     instance->td->argv[i++] = strdup(buffer);
  488.     snprintf(buffer, 1024, "%s", xval);
  489.     instance->td->argv[i++] = strdup(buffer);
  490.     snprintf(buffer, 1024, "-y");
  491.     instance->td->argv[i++] = strdup(buffer);
  492.     snprintf(buffer, 1024, "%s", yval);
  493.     instance->td->argv[i++] = strdup(buffer);
  494. }
  495.     }
  496. }
  497.     }
  499. //    if (instance->rtsp_use_tcp == 1) {
  500. //      snprintf(buffer, 1024, "-rtsp-stream-over-tcp");
  501. //      instance->td->argv[i++] = strdup(buffer);
  502. //    }
  503. //    if (instance->cachesize > 0) {
  504. //      snprintf(buffer, 1024, "-cache");
  505. //      instance->td->argv[i++] = strdup(buffer);
  506. //      snprintf(buffer, 1024, "%i", instance->cachesize);
  507. //      instance->td->argv[i++] = strdup(buffer);
  508. //    } else {
  509. //      snprintf(buffer, 1024, "-nocache");
  510. //      instance->td->argv[i++] = strdup(buffer);
  511. //    }
  513. //    if (instance->loop == 1) {
  514. //      snprintf(instance->td->argv[i++], 1024, "-loop");
  515. //      snprintf(instance->td->argv[i++], 1024, "0");
  516. //    }
  518.     if (instance->vo) {
  519. snprintf(buffer, 1024, "-vo");
  520. instance->td->argv[i++] = strdup(buffer);
  521. snprintf(buffer, 1024, "%s", instance->vo);
  522. instance->td->argv[i++] = strdup(buffer);
  523. if ((strncmp(buffer, "x11", 3) == 0)
  524.     || (strstr(buffer, ",x11") != NULL)) {
  525.     snprintf(buffer, 1024, "-zoom"); /* -vo x11 needs -zoom for rescaling */
  526.     instance->td->argv[i++] = strdup(buffer);
  527. }
  528.     }
  530.     if (instance->ao) {
  531. snprintf(buffer, 1024, "-ao");
  532. instance->td->argv[i++] = strdup(buffer);
  533. snprintf(buffer, 1024, "%s", instance->ao);
  534. instance->td->argv[i++] = strdup(buffer);
  535.     }
  537.     if (instance->af) {
  538. snprintf(buffer, 1024, "-af");
  539. instance->td->argv[i++] = strdup(buffer);
  540. snprintf(buffer, 1024, "%s", instance->af);
  541. instance->td->argv[i++] = strdup(buffer);
  542.     }
  544.     if (instance->output_display) {
  545. snprintf(buffer, 1024, "-display");
  546. instance->td->argv[i++] = strdup(buffer);
  547. snprintf(buffer, 1024, "%s", instance->output_display);
  548. instance->td->argv[i++] = strdup(buffer);
  549.     }
  551.     if (instance->framedrop == 1) {
  552. snprintf(buffer, 1024, "-framedrop");
  553. instance->td->argv[i++] = strdup(buffer);
  554.     }
  556.     if (instance->autosync > 0) {
  557. snprintf(buffer, 1024, "-autosync");
  558. instance->td->argv[i++] = strdup(buffer);
  559. snprintf(buffer, 1024, "%i", instance->autosync);
  560. instance->td->argv[i++] = strdup(buffer);
  561.     }
  563.     if (instance->mc > 0) {
  564. snprintf(buffer, 1024, "-mc");
  565. instance->td->argv[i++] = strdup(buffer);
  566. snprintf(buffer, 1024, "%i", instance->mc);
  567. instance->td->argv[i++] = strdup(buffer);
  568.     }
  570.     snprintf(buffer, 1024, "-osdlevel");
  571.     instance->td->argv[i++] = strdup(buffer);
  572.     snprintf(buffer, 1024, "%i", instance->osdlevel);
  573.     instance->td->argv[i++] = strdup(buffer);
  575.     /* some extra flags for download */
  576.     snprintf(buffer, 1024, "-nojoystick"); /* annoying... */
  577.     instance->td->argv[i++] = strdup(buffer);
  578.     if (instance->noconsolecontrols) {
  579. snprintf(buffer, 1024, "-noconsolecontrols");
  580. instance->td->argv[i++] = strdup(buffer);
  581.     }
  583.     if (instance->cookies) {
  584. snprintf(buffer, 1024, "-cookies");
  585. instance->td->argv[i++] = strdup(buffer);
  586.     }
  587. //    snprintf(buffer, 1024, "-nofs");  /* no full screen */
  588. //    instance->td->argv[i++] = strdup(buffer);
  589.     snprintf(buffer, 1024, "-slave"); /* slave mode */
  590.     instance->td->argv[i++] = strdup(buffer);
  591.     instance->td->argv[i++] = NULL;
  593.     // ok we have the command line setup
  594.     if (DEBUG)
  595. printf("ready to setup threadsn");
  597.     pthread_attr_setdetachstate(&(instance->thread_attr),
  598. PTHREAD_CREATE_JOINABLE);
  600.     if (DEBUG)
  601. printf("creating thread - NP_EMBEDn");
  602. #ifdef X_ENABLED
  603.     DrawUI(instance->widget, instance, _("Getting playlist..."), 0, -1);
  604. #endif
  605. #ifdef GTK_ENABLED
  606.     if (instance->status != NULL)
  607. gtk_label_set_text(instance->status, _("Getting playlist..."));
  608. #endif
  610.     if (instance->state < STATE_GETTING_PLAYLIST)
  611. instance->state = STATE_GETTING_PLAYLIST;
  613.     if (0) {
  614. printf("SetupPlayer: printing instance->listn");
  615. printList(instance->list);
  616. printf("SetupPlayer: printing instance->td->listn");
  617. printList(instance->td->list);
  618.     }
  620.     if (DEBUG)
  621. printf("creating player threadn");
  624.     pthread_mutex_lock(&(instance->control_mutex));
  625.     instance->js_state = JS_STATE_UNDEFINED;
  626.     launchPlayerThread(instance);
  627.     instance->threadsetup = 1;
  628.     pthread_mutex_unlock(&(instance->control_mutex));
  630.     // recommended slight pause
  631.     usleep(1);
  633.     if (DEBUG)
  634. printf("MAIN THREAD DONEn");
  635. }
  637. void refresh_frame(char *buffer, _ThreadData * td, Node * node)
  638. {
  639.     int seconds;
  640.     static int oldseconds = -1;
  641.     char *start;
  642.     char *endptr;
  643.     area *runner;
  644.     area *this_area;
  645. #ifdef SMILDEBUG
  646.     static FILE *error = NULL;
  647.     char errortmp[64];
  648.     if (!error)
  649. error = fopen("/tmp/downloadplugin-smil.log", "a");
  650. #endif
  652.     /* just to be sure */
  653.     if (node == NULL || node->area == NULL)
  654. return;
  656.     start = buffer;
  657.     while ((start = strstr(start, "A:")) != NULL && strlen(start) > 7) {
  658. start += 2;
  659. seconds = (int) strtol(start, &endptr, 0);
  660. if (seconds == oldseconds || start == endptr)
  661.     continue;
  662. #ifdef SMILDEBUG
  663. strlcpy(errortmp, start, 63);
  664. errortmp[64] = 0;
  665. fprintf(error, "->seconds: %d, oldseconds: %d, buffer: '%s'n",
  666. seconds, oldseconds, errortmp);
  667. fflush(error);
  668. #endif
  669. runner = node->area;
  670. this_area = node->area;
  671. while (runner) {
  672.     if (runner->begin < seconds
  673. && runner->begin > this_area->begin)
  674. this_area = runner;
  675.     if (runner->begin == seconds) {
  676. NPN_GetURL(td->instance->mInstance,
  677.    runner->url, runner->target);
  678. break;
  679.     }
  680.     runner = runner->next;
  681. }
  682. /*
  683.  *  If it was a seek we have to follow.
  684.  */
  685. if ((oldseconds - seconds > 1 || seconds - oldseconds > 1)
  686.     && !runner)
  687.     NPN_GetURL(td->instance->mInstance, this_area->url,
  688.        this_area->target);
  689. oldseconds = seconds;
  690.     }
  691. }
  694. //return true if we should try to play this again immediately, false if not 
  696. PlayResult *playNode(ThreadData * local_td, Node * local_list,
  697.      char *local_url, int local_mmsstream, int *usefps,
  698.      int *nomouseinput, int *maybeplaylist)
  699. {
  701.     PlayResult *result = (PlayResult *) NPN_MemAlloc(sizeof(PlayResult));
  702.     char buffer[1024];
  703.     char message[1024];
  704.     int notfound;
  705.     char *vo;
  706.     char vm[10];
  707.     char *cf;
  708.     double cfpercent;
  709.     char *eos;
  710.     char *msg;
  712.     long cfbytes, flags = 0;
  713.     int i,amt;
  714.     int zerocfbytes_count = 0;
  715.     char url_copy[1024];
  716.     int c;
  717.     int length_request_count = 0;
  718.     float lastmedialength = -1.0;
  719.     int lastmediapercent = -1;
  720.     int lastpercent = -1;
  721. #ifdef GTK_ENABLED
  722.     int fsupdated = 0;
  723. #endif
  725.     result->errorcode = ERROR_NO_ERROR;
  726.     result->tryagain = TRYAGAIN_FALLBACK;
  727.     result->retval = FALSE;
  729. /*
  730.   the meaning of the above is as follows:
  731.    TRYAGAIN_TRUE:  we should definitely try playing this url again immediately
  732.    TRYAGAIN_FALSE: we should definitely NOT do that.
  733.    TRYAGAIN_FALLBACK if we should try playing this url again immediately
  734.                     only if we have a fallback url.
  736.    these are for internal use in this function only. The function
  737.    should still return either 0 or 1 (and never 2). 
  739. */
  741.     pthread_cleanup_push((void (*)(void *))
  742.  pthread_mutex_unlock,
  743.  (void *) &(local_td->instance->control_mutex));
  744.     pthread_mutex_lock(&(local_td->instance->control_mutex));
  745.     sendCommand(local_td->instance, "get_time_length");
  746.     local_td->instance->mediaLength = 0.0;
  747.     pthread_mutex_unlock(&(local_td->instance->control_mutex));
  748.     pthread_cleanup_pop(0);
  749. #ifdef GTK_ENABLED
  750.     g_idle_add(gtkgui_save_enable, local_td->instance);
  751. //      g_idle_add(gtkgui_refreshbuttonstate, local_td->instance);
  752. #endif
  754.     // set this to 0 for every new media file;
  755.     local_td->instance->movie_height = 0;
  756.     local_td->instance->movie_width = 0;
  758.     if (local_td->instance->player != NULL) {
  759. if (DEBUG) {
  760.     printf("Getting file mode flagsn");
  761. }
  762. flags = fcntl(fileno(local_td->instance->player), F_GETFL, 0);
  763.     }
  764.     
  765.     while (1) {
  766. pthread_testcancel();
  767. if (local_td->instance->player == NULL)
  768.     break;
  770. if (feof(local_td->instance->player)) {
  771.     pthread_testcancel();
  772.     break;
  773. }
  774. pthread_testcancel();
  776. assert(local_td != NULL);
  777. assert(local_td->instance != NULL);
  778. assert(local_td->instance->control > 0);
  779. assert(local_td->instance->player != NULL);
  781. pthread_testcancel();
  782. #ifdef GTK_ENABLED
  783. //      g_idle_add(gtkgui_save_enable, local_td->instance);
  784. //      g_idle_add(gtkgui_refreshbuttonstate, local_td->instance);
  785. #endif
  787. pthread_testcancel();
  788. if (local_td->instance->player != NULL) {
  789.     // if (fgets(buffer, 1024, local_td->instance->player) == NULL) {
  790.     //  continue;
  791.     // }
  793.     // fgets is not a pthread cancel point, so we basically have to rewrite fgets
  794.     // to make this work better. If we cancel the thread while fgets is waiting for 
  795.     // for an EOS then we crash.
  796.     buffer[0] = '';
  797.     i = 0;
  798.     do {
  799. pthread_testcancel();
  800. // need to lock around the read
  801. pthread_mutex_lock(&(local_td->instance->read_mutex));
  803. if ((local_td->instance->cancelled == 0)
  804.     && (local_td->instance->player != NULL)) {
  805.     // c = fgetc(local_td->instance->player);
  806.          amt = fread(&c, 1, 1, local_td->instance->player);
  807. } else {
  808.     c = EOF;
  809.     amt = 0;
  810. }
  811. pthread_mutex_unlock(&(local_td->instance->read_mutex));
  813. if (c == EOF) {
  814.     buffer[i] = '';
  815.     break;
  816. }
  817. if (c == 0)
  818.     continue;
  819. buffer[i] = (char) c;
  820. i += amt;
  821. if (i >= 1024) {
  822.     buffer[1023] = '';
  823.     break;
  824. }
  825.     } while (((unsigned char) c != 'n'));
  826.     if (buffer[0] == '')
  827. continue;
  828.     else if (i < 1024) // make sure we don't access out of bounds
  829. buffer[i] = ''; // make sure we NULL terminate the string
  831. }
  833.   pthread_testcancel();
  835. if (DEBUG) {
  836.     if (strlen(buffer) > 0)
  837.      printf("READ: %s n", buffer);
  838. }
  840. refresh_frame(buffer, local_td, local_list);
  841.         
  842.     
  843. pthread_testcancel();
  844. if (strstr(buffer, "STREAM") != NULL) {
  845.     if (local_td->instance->player != NULL) {
  846. if (DEBUG) {
  847.     printf("Setting file mode to non-blockingn");
  848. }
  849. fcntl(fileno(local_td->instance->player), F_SETFL, flags | O_NONBLOCK);
  850.     }
  851. }    
  853. pthread_testcancel();
  854. if (strstr(buffer, "Cache size") != NULL || strstr(buffer, "Starting playback") != NULL ) {
  855.     if (local_td->instance->player != NULL) {
  856. if (DEBUG) {
  857.     printf("Setting file mode back to blockingn");
  858. }
  859. fcntl(fileno(local_td->instance->player), F_SETFL, flags);
  860.     }
  861. }    
  862.     
  863.     
  864. pthread_testcancel();
  865. if (strstr(buffer, "Cache fill:") != NULL) {
  866.     strlcpy(message, strstr(buffer, "Cache fill"), 1024);
  867.     notfound = 1;
  868.     while (notfound) {
  869. eos = strrchr(message, 'r');
  870. if (eos == NULL)
  871.     eos = message;
  872. if (strstr(eos, "Cache fill:") == NULL) {
  873.     // if we don't find "Cache fill:" then replace the r with , making message shorter
  874.     eos[0] = '';
  875.     // break out of the loop if too short
  876.     if (strlen(message) < 5)
  877. break;
  878. } else {
  879.     // if we found the last one in the message string, move from r to C in the string
  880.     eos++;
  881.     notfound = 0;
  882. }
  883.     }
  885.     // Only update the display if there is something worth displaying
  886.     if (strstr(eos, "Cache fill:") != NULL) {
  887. cf = strstr(eos, "Cache fill:");
  888. lastpercent = (int) cfpercent;
  889. i = sscanf(cf, "Cache fill: %lf %% (%ld bytes)",
  890.    &cfpercent, &cfbytes);
  891. //the following is a workaround for an download bug
  892. // we can try to fallback to mmst when we get
  893. // Cache Fill: 0% (0 bytes) several times.
  894. if (i == 2 && cfbytes == 0) {
  895.     zerocfbytes_count++;
  896. }
  897. if (DEBUG && zerocfbytes_count > 0) {
  898.     printf("Cache Fill: 0%% (0 bytes), count = %dn",
  899.    zerocfbytes_count);
  900. }
  901. if (zerocfbytes_count >= 1 &&
  902.     ((strncmp(local_url, "mms://", 6) == 0) ||
  903.      (local_mmsstream
  904.       && strncmp(local_url, "http://", 7) == 0))) {
  906.     if (DEBUG) {
  907. printf("Exiting. Will try again with mmst://n");
  908.     }
  909.     result->tryagain = TRYAGAIN_FALLBACK;
  910.     break;
  911. }
  913. snprintf(message, 1024, _("Buffering %s"), local_url);
  915. #ifdef X_ENABLED
  916. DrawUI(local_td->instance->widget,
  917.        local_td->instance, eos, -1, (int) cfpercent);
  918. #endif
  919. #ifdef GTK_ENABLED
  920. snprintf(local_td->instance->lastmessage, 1024, "%s",
  921.  message);
  923. local_td->instance->percent = (cfpercent / 100.0);
  924. if (lastpercent != cfpercent) {
  925.     g_idle_add(gtkgui_message, local_td->instance);
  926.     g_idle_add(gtkgui_progress, local_td->instance);
  927. }
  928. #endif
  929. pthread_mutex_lock(&(local_td->instance->control_mutex));
  930. local_td->instance->js_state = JS_STATE_BUFFERING;
  931. pthread_mutex_unlock(&(local_td->instance->control_mutex));
  933.     }
  934. }
  936. pthread_testcancel();
  937. if (strstr(buffer, "Starting") != NULL) {
  938.     snprintf(message, 1024, _("Playing %s"), local_url);
  939. #ifdef X_ENABLED
  940.     DrawUI(local_td->instance->widget,
  941.    local_td->instance, message, 0, -1);
  942. #endif
  943. #ifdef GTK_ENABLED
  944.     snprintf(local_td->instance->lastmessage, 1024, "%s", message);
  945.     g_idle_add(gtkgui_message, local_td->instance);
  946. #endif
  947.     pthread_mutex_lock(&(local_td->instance->control_mutex));
  948.     local_td->instance->js_state = JS_STATE_PLAYING;
  949.     pthread_mutex_unlock(&(local_td->instance->control_mutex));
  950. }
  952. pthread_testcancel();
  953. if (strstr(buffer, "VO:") != NULL) {
  954.     fcntl(fileno(local_td->instance->player), F_SETFL, flags);
  955.     if (local_td->instance->mode == NP_EMBED
  956. && local_td->instance->noembed == 0)
  957. local_td->instance->noredraw = 1;
  958.     vo = strstr(buffer, "VO:");
  959.     sscanf(vo, "VO: [%9[^]]] %ix%i => %ix%i", vm,
  960.    &(local_list->actual_x),
  961.    &(local_list->actual_y),
  962.    &(local_list->play_x), &(local_list->play_y));
  963.     if (local_td->instance->mode == NP_EMBED
  964. && local_td->instance->noembed == 0) {
  965. if (local_td->instance->panel_height == 0)
  966.     local_td->instance->panel_height =
  967. local_td->instance->embed_height -
  968. local_list->play_y;
  970. if (local_td->instance->player_window != 0
  971.     && local_td->instance->movie_height !=
  972.     local_list->play_y) {
  974.     local_td->instance->movie_height = local_list->play_y;
  975.     local_td->instance->movie_width = local_list->play_x;
  976. #ifdef GTK_ENABLED
  977.     g_idle_add(gtkgui_resize, local_td->instance);
  978.     g_idle_add(gtkgui_draw, local_td->instance);
  979. #endif
  980. }
  982. if (DEBUG)
  983.     printf
  984. ("----player thread: panel height in thread = %in",
  985.  local_td->instance->panel_height);
  987.     } else {
  988. local_td->instance->panel_height = 16;
  989. if (local_td->instance->player_window != 0
  990.     && local_td->instance->movie_height !=
  991.     local_list->play_y) {
  992.     local_td->instance->movie_height = local_list->play_y;
  993.     local_td->instance->movie_width = local_list->play_x;
  995. #ifdef GTK_ENABLED
  996.     g_idle_add(gtkgui_resize, local_td->instance);
  997. #endif
  998. }
  999. local_td->instance->embed_height =
  1000.     local_td->instance->window_height;
  1001. local_td->instance->embed_width =
  1002.     local_td->instance->window_width;
  1003. local_td->instance->panel_height =
  1004.     local_td->instance->window_height;
  1005. #ifdef GTK_ENABLED
  1006. g_idle_add(gtkgui_draw, local_td->instance);
  1007. #endif
  1008.     }
  1010. }
  1012. pthread_testcancel();
  1013. if (strstr(buffer, "Video: no video") != NULL) {
  1014.     fcntl(fileno(local_td->instance->player), F_SETFL, flags);
  1015.     if (local_td->instance->panel_height == 0)
  1016. local_td->instance->panel_height = 32;
  1017.     local_td->instance->noredraw = 0;
  1018.     local_td->instance->movie_height = 1;
  1019.     local_td->instance->movie_width = 1;
  1020. #ifdef GTK_ENABLED
  1021.     g_idle_add(gtkgui_resize, local_td->instance);
  1022.     g_idle_add(gtkgui_draw, local_td->instance);
  1023. #endif
  1024. }
  1026. pthread_testcancel();
  1027. // download answer back messages
  1028. if (strstr(buffer, "ANS_LENGTH") != 0) {
  1029.     if ((int) local_td->instance->mediaLength != 0)
  1030. lastmedialength = local_td->instance->mediaLength;
  1031.     msg = strstr(buffer, "ANS_LENGTH");
  1032.     sscanf(msg, "ANS_LENGTH=%f",
  1033.    &(local_td->instance->mediaLength));
  1034.     if (DEBUG > 1)
  1035. printf("Media Length = %fn",
  1036.        local_td->instance->mediaLength);
  1037. }
  1039. pthread_testcancel();
  1040. // download answer back messages
  1041. if (strstr(buffer, "ANS_TIME_POSITION") != 0) {
  1042.     msg = strstr(buffer, "ANS_TIME_POSITION");
  1043.     sscanf(msg, "ANS_TIME_POSITION=%f",
  1044.    &(local_td->instance->mediaPos));
  1045.     if (DEBUG > 1)
  1046. printf("Media Position = %fn",
  1047.        local_td->instance->mediaPos);
  1048.     if ((int) local_td->instance->mediaLength > 1) {
  1049. lastmediapercent = local_td->instance->mediaPercent;
  1050. local_td->instance->mediaPercent =
  1051.     (int) ((local_td->instance->mediaPos * 100) /
  1052.    local_td->instance->mediaLength);
  1053. #ifdef GTK_ENABLED
  1054. if (lastmediapercent != local_td->instance->mediaPercent) {
  1055.     g_idle_add(gtkgui_drawMediaProgress,
  1056.        local_td->instance);
  1057.     g_idle_add(gtkgui_refreshbuttonstate,
  1058.        local_td->instance);
  1059. }
  1060. #endif
  1061.     }
  1062. }
  1064. pthread_testcancel();
  1065. if (strstr(buffer, "ANS_PERCENT_POSITION") != 0) {
  1066.     msg = strstr(buffer, "ANS_PERCENT_POSITION");
  1067.     sscanf(msg, "ANS_PERCENT_POSITION=%i",
  1068.    &(local_td->instance->mediaPercent));
  1069.     if (local_td->instance->mediaPercent == 0) {
  1070. if ((int) local_td->instance->mediaLength > 1)
  1071.     lastmediapercent = local_td->instance->mediaPercent;
  1072. local_td->instance->mediaPercent =
  1073.     (int) ((local_td->instance->mediaPos * 100) /
  1074.    local_td->instance->mediaLength);
  1075. #ifdef GTK_ENABLED
  1076. if (lastmediapercent != local_td->instance->mediaPercent) {
  1077.     g_idle_add(gtkgui_drawMediaProgress,
  1078.        local_td->instance);
  1079.     g_idle_add(gtkgui_refreshbuttonstate,
  1080.        local_td->instance);
  1081. }
  1082. #endif
  1083.     }
  1084.     if (DEBUG > 1)
  1085. printf("Percent Played = %in",
  1086.        local_td->instance->mediaPercent);
  1087. }
  1089. pthread_testcancel();
  1090. // this is only needed for the retry code
  1091. if (strstr(buffer, "rA:") != 0 || strstr(buffer, "rV:") != 0) {
  1092.     //audio or video is playing
  1093.     msg = strstr(buffer, "rA:");
  1094.     if (msg != NULL) {
  1095. sscanf(msg, "rA:%f", &(local_td->instance->mediaTime));
  1096. if (DEBUG > 1)
  1097.     printf("mediaTime = %fn",
  1098.    local_td->instance->mediaTime);
  1099. #ifdef GTK_ENABLED
  1100. //              g_idle_add(gtkgui_draw, local_td->instance);
  1101. #endif
  1102.     } else {
  1103. msg = strstr(buffer, "rV:");
  1104. if (msg != NULL) {
  1105.     sscanf(msg, "rV:%f",
  1106.    &(local_td->instance->mediaTime));
  1107.     if (DEBUG > 1)
  1108. printf("mediaTime = %fn",
  1109.        local_td->instance->mediaTime);
  1110. }
  1111.     }
  1112.     pthread_cleanup_push((void (*)(void *))
  1113.  pthread_mutex_unlock,
  1114.  (void *) &(local_td->instance->
  1115.     control_mutex));
  1116.     pthread_mutex_lock(&(local_td->instance->control_mutex));
  1118.     if ((local_td->instance->js_state != JS_STATE_STOPPED)
  1119. && (local_td->instance->js_state != JS_STATE_PAUSED))
  1120. local_td->instance->js_state = JS_STATE_PLAYING;
  1122.     pthread_mutex_unlock(&(local_td->instance->control_mutex));
  1123.     pthread_cleanup_pop(0);
  1124.     pthread_testcancel();
  1125.     if (local_td->instance->paused == 0) {
  1126. pthread_cleanup_push((void (*)(void *))
  1127.      pthread_mutex_unlock,
  1128.      (void *) &(local_td->instance->
  1129. control_mutex));
  1130. pthread_mutex_lock(&(local_td->instance->control_mutex));
  1131. if ((int) local_td->instance->mediaLength > 1)
  1132.     sendCommand(local_td->instance, "get_time_pos");
  1133. if (local_td->instance->mediaLength > lastmedialength) {
  1134.     sendCommand(local_td->instance, "get_time_length");
  1135. } else {
  1136.     if (length_request_count < 10) {
  1137. sendCommand(local_td->instance, "get_time_length");
  1138. length_request_count++;
  1139.     }
  1140. }
  1141. pthread_mutex_unlock(&(local_td->instance->control_mutex));
  1142. pthread_cleanup_pop(0);
  1143. #ifdef GTK_ENABLED
  1144. if (fsupdated == 0) {
  1145.     g_idle_add(gtkgui_updatefullscreen,
  1146.        local_td->instance);
  1147.     fsupdated = 1;
  1148. }
  1149. #endif
  1150.     }
  1151.     result->tryagain = TRYAGAIN_FALSE;
  1152. }
  1154. pthread_testcancel();
  1155. if (strstr(buffer, "Connect") != NULL) {
  1156.     snprintf(message, 1024, "%s", buffer);
  1157. #ifdef X_ENABLED
  1158.     DrawUI(local_td->instance->widget,
  1159.    local_td->instance, message, 0, -1);
  1160. #endif
  1161. #ifdef GTK_ENABLED
  1162.     snprintf(local_td->instance->lastmessage, 1024, "%s", message);
  1163.     g_idle_add(gtkgui_message, local_td->instance);
  1164. #endif
  1165.     pthread_mutex_lock(&(local_td->instance->control_mutex));
  1166.     local_td->instance->js_state = JS_STATE_WAITING;
  1167.     pthread_mutex_unlock(&(local_td->instance->control_mutex));
  1169. }
  1171. pthread_testcancel();
  1172. if (strstr(buffer, "Initiated") != NULL) {
  1173.     snprintf(message, 1024, "%s", buffer);
  1174. #ifdef X_ENABLED
  1175.     DrawUI(local_td->instance->widget,
  1176.    local_td->instance, message, 0, -1);
  1177. #endif
  1178. #ifdef GTK_ENABLED
  1179.     snprintf(local_td->instance->lastmessage, 1024, "%s", message);
  1180.     g_idle_add(gtkgui_message, local_td->instance);
  1181. #endif
  1182. }
  1184. pthread_testcancel();
  1185. if (strstr(buffer, "No stream found") != NULL) {
  1186.     snprintf(message, 1024, "%s", buffer);
  1187. #ifdef X_ENABLED
  1188.     DrawUI(local_td->instance->widget,
  1189.    local_td->instance, message, 0, -1);
  1190. #endif
  1191. #ifdef GTK_ENABLED
  1192.     snprintf(local_td->instance->lastmessage, 1024, "%s", message);
  1193.     g_idle_add(gtkgui_message, local_td->instance);
  1194. #endif
  1195.     result->tryagain = TRYAGAIN_FALSE;
  1196.     result->errorcode = ERROR_NO_STREAM;
  1197.     break;
  1198. }
  1201. pthread_testcancel();
  1202. if (strstr(buffer, "Example: download -playlist ") != NULL) {
  1203.     if (*maybeplaylist == 0) {
  1204. result->tryagain = TRYAGAIN_TRUE;
  1205. *maybeplaylist = 1;
  1206.     } else {
  1207. result->tryagain = TRYAGAIN_FALSE;
  1208. result->errorcode = ERROR_NOT_PLAYLIST;
  1209.     }
  1210.     break;
  1211. }
  1214.        pthread_testcancel();
  1215.        if (strstr(buffer, "Failed to open") != NULL) {
  1216.            if ((strstr(buffer, "/dev/rtc") == NULL) 
  1217.          && (strstr(buffer, "LIRC") == NULL) 
  1218.      && (strstr(buffer, "registry file") == NULL)) { // ignore RTC device and LIRC device failures
  1219.        if (local_td->instance->currentnode->mmsstream == 1) {
  1220.     if (DEBUG)
  1221.     printf("Trying fallbackn");
  1222.     result->tryagain = TRYAGAIN_FALLBACK;
  1223.     break;
  1224.        } else {
  1225.     result->tryagain = TRYAGAIN_FALSE;
  1226.     result->errorcode = ERROR_FILE_NOT_FOUND;
  1227.     break;
  1228.        }
  1229.    }
  1230. }
  1232. pthread_testcancel();
  1233. if (strstr(buffer, "Error while decoding") != NULL) {
  1234.     if (!isMms(local_url, local_td->instance->nomediacache)) {
  1235. if (DEBUG)
  1236.     printf("Resetting stream, 1 sec rewindn");
  1237. pthread_suspend(1000);
  1238. pthread_cleanup_push((void (*)(void *))
  1239.      pthread_mutex_unlock,
  1240.      (void *) &(local_td->instance->
  1241. control_mutex));
  1242. pthread_mutex_lock(&(local_td->instance->control_mutex));
  1243. sendCommand(local_td->instance, "seek -1 0n");
  1244. pthread_mutex_unlock(&(local_td->instance->control_mutex));
  1245. pthread_cleanup_pop(0);
  1247.     }
  1248. }
  1250. pthread_testcancel();
  1251. if (strstr(buffer, "Quit") != NULL) {
  1252.     if (DEBUG)
  1253. printf("----player thread: breaking read loop - Quitn");
  1254.     local_td->instance->js_state = JS_STATE_UNDEFINED;
  1255.     result->tryagain = TRYAGAIN_FALSE;
  1256.     result->errorcode = ERROR_QUIT;
  1257.     break;
  1258. }
  1260. pthread_testcancel();
  1261. if (strstr
  1262.     (buffer,
  1263.      "download interrupted by signal 13 in module: demux_open") !=
  1264.     NULL) {
  1265.     if (DEBUG)
  1266. printf
  1267.     ("----player thread: breaking read loop - demux_openn");
  1268.     local_td->instance->js_state = JS_STATE_UNDEFINED;
  1269.     if (local_td->instance->rtsp_use_tcp == 1) {
  1270. local_td->instance->rtsp_use_tcp = 0;
  1271. result->tryagain = TRYAGAIN_TRUE;
  1272.     } else {
  1273. result->tryagain = TRYAGAIN_FALSE;
  1274. result->errorcode = ERROR_PLAYER_INTERRUPTED;
  1275.     }
  1276.     break;
  1277. }
  1280. pthread_testcancel();
  1281. // detect Quicktime file with old codec
  1282. if (strstr(buffer, "MOV: missing header (moov/cmov) chunk!") !=
  1283.     NULL) {
  1284.     if (DEBUG) {
  1285. printf
  1286.     ("----player thread: waiting to download entire movien");
  1287.     }
  1288.     result->tryagain = TRYAGAIN_TRUE;
  1289.     while (1) {
  1290. pthread_testcancel();
  1291. usleep(100);
  1292. pthread_testcancel();
  1293. pthread_mutex_lock(&(local_td->instance->control_mutex));
  1294. local_td->instance->js_state = JS_STATE_BUFFERING;
  1295. pthread_mutex_unlock(&(local_td->instance->control_mutex));
  1296. pthread_mutex_lock(&(local_td->instance->playlist_mutex));
  1297. local_td->instance->state = STATE_DOWNLOADING;
  1298. if (local_list->retrieved == 1) {
  1299.     local_td->instance->state = STATE_PLAYING;
  1300.     pthread_mutex_lock(&
  1301.        (local_td->instance->
  1302. control_mutex));
  1303.     local_td->instance->js_state = JS_STATE_PLAYING;
  1304.     pthread_mutex_unlock(&
  1305.  (local_td->instance->
  1306.   control_mutex));
  1307.     pthread_mutex_unlock(&
  1308.  (local_td->instance->
  1309.   playlist_mutex));
  1310.     printf("----player thread: Movie downloadedn");
  1311.     break;
  1312. }
  1313. pthread_mutex_unlock(&
  1314.      (local_td->instance->playlist_mutex));
  1315.     }
  1316.     break;
  1317. }
  1319. pthread_testcancel();
  1320. if (strstr(buffer, "FPS not specified") != NULL) {
  1321.     result->tryagain = TRYAGAIN_TRUE;
  1322.     *usefps = 1;
  1323.     break;
  1324. }
  1326. pthread_testcancel();
  1327. if (strstr(buffer, "nomouseinput") != NULL) {
  1328.     *nomouseinput = 0;
  1329.     result->tryagain = TRYAGAIN_TRUE;
  1330.     break;
  1331. }
  1333. /* pthread_testcancel();
  1334. if (strstr(buffer, "Win32 LoadLibrary failed to load") != NULL) {
  1335.     if (local_td->instance->useragent != NULL) {
  1336. free(local_td->instance->useragent);
  1337. local_td->instance->useragent = NULL;
  1338. result->tryagain = TRYAGAIN_TRUE;
  1339. break;
  1340.     }
  1341. }
  1342. */
  1343. pthread_testcancel();
  1344. if (strstr(buffer, "Exiting") != NULL) {
  1345.     if (DEBUG)
  1346. printf
  1347.     ("----player thread: breaking read loop - Exitingn");
  1348.     if (local_td->instance->mediaPercent != 0) {
  1349. local_td->instance->mediaPercent = 100;
  1350. #ifdef GTK_ENABLED
  1351. g_idle_add(gtkgui_drawMediaProgress, local_td->instance);
  1352. #endif
  1353.     }
  1354.     result->tryagain = TRYAGAIN_FALSE;
  1355.     result->errorcode = ERROR_NO_ERROR;
  1356.     break;
  1357. }
  1359. pthread_testcancel();
  1360. // break out if download crashes
  1361. if (strstr(buffer, "interrupted") != NULL) {
  1362.     if (DEBUG)
  1363. printf
  1364.     ("----player thread: breaking read loop - interruptedn");
  1365.     if (strstr(buffer, "video_read_frame") != NULL) {
  1366. local_td->instance->js_state = JS_STATE_UNDEFINED;
  1367. if (local_td->instance->rtsp_use_tcp == 1) {
  1368.     local_td->instance->rtsp_use_tcp = 0;
  1369.     result->tryagain = TRYAGAIN_TRUE;
  1370. } else {
  1371. #ifdef GTK_ENABLED
  1372.     snprintf(local_td->instance->lastmessage, 1024,
  1373.      "Error: %s", buffer);
  1374.     g_idle_add(gtkgui_message, local_td->instance);
  1375. #endif
  1376.     result->tryagain = TRYAGAIN_FALSE;
  1377.     result->errorcode = ERROR_PLAYER_INTERRUPTED;
  1378. }
  1379.     }
  1380.     break;
  1381. }
  1383. pthread_testcancel();
  1384. if (strstr(buffer, "execv") != NULL) {
  1385.     if (DEBUG)
  1386. printf
  1387.     ("----player thread: breaking read loop - execv failedn");
  1388.     local_td->instance->js_state = JS_STATE_UNDEFINED;
  1389. #ifdef GTK_ENABLED
  1390.     snprintf(local_td->instance->lastmessage, 1024, "Error: %s %s",
  1391.      local_td->argv[0], buffer);
  1392.     g_idle_add(gtkgui_message, local_td->instance);
  1393. #endif
  1394.     result->tryagain = TRYAGAIN_FALSE;
  1395.     result->errorcode = ERROR_EXECV;
  1396.     break;
  1397. }
  1399. pthread_testcancel();
  1400. if (strstr(buffer, "explicit kill") != NULL) {
  1401.     if (DEBUG)
  1402. printf("----player thread: breaking read loop - killedn");
  1403.     result->tryagain = TRYAGAIN_FALSE;
  1404.     result->errorcode = ERROR_EXPLICIT_KILL;
  1405.     break;
  1406. }
  1408. pthread_testcancel();
  1409. if (strstr(buffer, "decoder is not supposed") != NULL) {
  1410.     if (DEBUG)
  1411. printf
  1412.     ("----player thread: breaking read loop - codec failuren");
  1413. #ifdef GTK_ENABLED
  1414.     snprintf(local_td->instance->lastmessage, 1024, "Error: %s %s",
  1415.      local_td->argv[0], buffer);
  1416.     g_idle_add(gtkgui_message, local_td->instance);
  1417. #endif
  1418.     result->tryagain = TRYAGAIN_FALSE;
  1419.     result->errorcode = ERROR_CODEC_FAILURE;
  1420.     break;
  1421. }
  1423. pthread_testcancel();
  1424. if (strstr(buffer, "Failed to decode frame") != NULL) {
  1425.     if (DEBUG)
  1426. printf
  1427.     ("----player thread: breaking read loop - codec failuren");
  1428. #ifdef GTK_ENABLED
  1429.     snprintf(local_td->instance->lastmessage, 1024, "Error: %s %s",
  1430.      local_td->argv[0], buffer);
  1431.     g_idle_add(gtkgui_message, local_td->instance);
  1432. #endif
  1433.     result->tryagain = TRYAGAIN_FALSE;
  1434.     result->errorcode = ERROR_CODEC_FAILURE;
  1435.     break;
  1436. }
  1438. pthread_testcancel();
  1439. /* commmented out to make BBC site work    
  1440. if (strstr(buffer, "everything done") != NULL) {
  1441.     if (DEBUG)
  1442. printf
  1443.     ("----player thread: breaking read loop - codec issuen");
  1444.     result->tryagain = TRYAGAIN_FALSE;
  1445.     result->errorcode = ERROR_CODEC_FAILURE;
  1446.     break;
  1447. }
  1448. */
  1450. assert(local_td->instance->player != NULL);
  1451.     } // end of READ LOOP
  1453.     if (DEBUG) {
  1454. printf("----player thread: tryagain = %dn", result->tryagain);
  1455.     }
  1456.     //we always return either true or false
  1457.     if (result->tryagain == TRYAGAIN_TRUE) {
  1458. result->retval = TRUE;
  1459.     }
  1461.     if (result->tryagain == TRYAGAIN_FALSE) {
  1462. result->retval = FALSE;
  1463.     }
  1465.     if (result->tryagain == TRYAGAIN_FALLBACK) {
  1466. //fallback to msst and then to http if we can
  1467. strlcpy(url_copy, local_url, 1023);
  1468. url_copy[1023] = '';
  1470. if (strncmp(local_url, "mms://", 6) == 0) {
  1471.     snprintf(local_url, 1023, "mmst://%s", url_copy + 6);
  1472.     result->retval = TRUE;
  1473. } else if (local_mmsstream &&
  1474.    strncmp(local_url, "mmst://", 7) == 0) {
  1476.     snprintf(local_url, 1023, "http://%s", url_copy + 7);
  1477.     result->retval = TRUE;
  1478. } else {
  1479.     result->retval = FALSE;
  1480. }
  1481.         if (DEBUG) 
  1482.      printf("TRYAGAIN_FALLBACK entered, new url is %sn", local_url);
  1483.     }
  1484. #ifdef GTK_ENABLED
  1485.     if (strstr(local_td->instance->lastmessage, "Error") == NULL) {
  1486. snprintf(local_td->instance->lastmessage, 1024, _("Stopped"));
  1487. g_idle_add(gtkgui_message, local_td->instance);
  1488.     }
  1489. #endif
  1490.     return result;
  1491. }
  1493. void *playPlaylist(void *td)
  1494. {
  1496.     PlayResult *result = NULL;
  1497.     FILE *playlist;
  1498.     char cmd[2048];
  1499.     char message[1024];
  1500.     char mmsplaylist[1024];
  1501.     char buffer[1024]; // scratch pad
  1502.     char *p; // pointer to find the ( in the callback
  1504.     int argc = 0, base_argc = 0;
  1505.     ThreadData *local_td;
  1506.     Node *local_list;
  1507.     char local_url[1024];
  1508.     int local_mmsstream;
  1509.     int i;
  1510.     int loop_single = 0;
  1511.     int loop_count;
  1512.     Node *node;
  1514.     int tryagain;
  1515.     int usefps;
  1516.     int nomouseinput;
  1517.     int maybeplaylist;
  1518.     int listempty;
  1519.     int lasterror = -1;
  1521.     local_td = (ThreadData *) td;
  1522.     local_list = local_td->list;
  1524.     if (local_td == NULL)
  1525. pthread_exit(0);
  1527.     if (DEBUG)
  1528. printf("----player thread: in playPlaylistn");
  1530.     pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock,
  1531.  (void *) &(local_td->instance->
  1532.     playlist_cond_mutex));
  1533.     pthread_mutex_lock(&(local_td->instance->playlist_cond_mutex));
  1535.     pthread_mutex_lock(&(local_td->instance->control_mutex));
  1536.     local_td->instance->js_state = JS_STATE_BUFFERING;
  1537.     pthread_mutex_unlock(&(local_td->instance->control_mutex));
  1539.     if (DEBUG)
  1540. printf
  1541.     ("----player thread: about to go to sleep, js_state = %d, state = %dn",
  1542.      local_td->instance->js_state, local_td->instance->state);
  1545.     if (local_td->instance->state < STATE_STARTED_PLAYER) {
  1546. // wait for playlist_complete_cond to be signalled
  1547. // this should happen when we have completed getting all the playlist elements
  1548. local_td->instance->state = STATE_WAITING_FOR_SIGNAL;
  1549. pthread_cond_wait(&(local_td->instance->playlist_complete_cond),
  1550.   &(local_td->instance->playlist_cond_mutex));
  1551. pthread_mutex_unlock(&(local_td->instance->playlist_cond_mutex));
  1553. pthread_testcancel();
  1554. sleep(1);
  1555. // playlist_cond_mutex should be unlocked now
  1556. if (local_td != NULL) {
  1557.     if (DEBUG > 1)
  1558. printf("local_td = %pn", local_td);
  1559.     if (local_td->instance != NULL) {
  1560. if (DEBUG > 1)
  1561.     printf("local_td->instance = %pn",
  1562.    local_td->instance);
  1564. pthread_testcancel();
  1565. local_td->instance->state = STATE_STARTED_PLAYER;
  1566. if (DEBUG)
  1567.     printf
  1568. ("---player thread: got wakeup signal, js_state = %d, state = %dn",
  1569.  local_td->instance->js_state,
  1570.  local_td->instance->state);
  1571.     } else {
  1572. if (DEBUG)
  1573.     printf
  1574. ("We were signalled to start but local_td->instance is NULL, should not happenn");
  1575. pthread_exit(0);
  1576.     }
  1577. } else {
  1578.     if (DEBUG)
  1579. printf
  1580.     ("We were signalled to start but local_td is NULL, should not happenn");
  1581.     pthread_exit(0);
  1582. }
  1583.     } else {
  1584. local_td->instance->threadsignaled = 1;
  1585.     }
  1587.     pthread_cleanup_pop(0);
  1589.     if (DEBUG)
  1590. printf("----player thread: playPlayList - waiting completen");
  1592.     pthread_testcancel();
  1593. #ifdef X_ENABLED
  1594.     DrawUI(local_td->w, local_td->instance, _("Loading Media..."), 0, -1);
  1595. #endif
  1596. #ifdef GTK_ENABLED
  1597.     snprintf(local_td->instance->lastmessage, 1024, _("Loading Media..."));
  1598.     g_idle_add(gtkgui_message, local_td->instance);
  1599. #endif
  1601.     memset(cmd, '', 1);
  1602.     i = 0;
  1603.     if (DEBUG)
  1604. printf("----player thread: building command stringn");
  1606.     pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock,
  1607.  (void *) &(local_td->instance->playlist_mutex));
  1608.     pthread_mutex_lock(&(local_td->instance->playlist_mutex));
  1610.     while (local_td->argv[argc] != NULL) {
  1611. if (DEBUG)
  1612.     printf("PLAY %i:%sn", i, local_td->argv[argc]);
  1613. argc++;
  1614.     }
  1616.     base_argc = argc;
  1618.     pthread_mutex_unlock(&(local_td->instance->playlist_mutex));
  1619.     pthread_cleanup_pop(0);
  1621.     //handle qtNext
  1622.     //shouldn't this be somewhere else?
  1623.     i = 0;
  1624.     while (local_td->instance->qtNext[i] != NULL) {
  1625. node = newNode();
  1626. if (DEBUG)
  1627.     printf("----player thread: adding %sn",
  1628.    local_td->instance->qtNext[i]);
  1629. strlcpy(node->url, local_td->instance->qtNext[i], 1024);
  1630. i++;
  1631. addToEnd(local_list, node);
  1632.     }
  1634.     // preview playlist
  1635.     local_list = local_td->list;
  1636.     if (DEBUG) {
  1637. while (local_list != NULL) {
  1638.     printf
  1639. ("----player thread:nlocal_list =  %pnPL URL: %snplay = %i, cancelled= %innext= %pn",
  1640.  local_list,
  1641.  local_list->url, local_list->play,
  1642.  local_list->cancelled, local_list->next);
  1643.     local_list = local_list->next;
  1644. }
  1645.     }
  1646.     // count playable items in the list, if playable =1 and loop = 1 then add a couple of args
  1647.     if (local_td->instance->loop >= 0) {
  1648. i = 0;
  1649. local_list = local_td->list;
  1650. while (local_list != NULL) {
  1651.     if (local_list->play)
  1652. i++;
  1653.     local_list = local_list->next;
  1654. }
  1655. if (DEBUG)
  1656.     printf
  1657. ("----player thread:nFound %i files to play and loop is truen",
  1658.  i);
  1660. // if the play count is exactly 1 then tell download to loop continuously and to use the same frame buffer (should eliminate blinking)
  1661. if (i == 1) {
  1662.     loop_single = 1;
  1663.     local_td->argv[argc++] = strdup("-loop");
  1664.     snprintf(buffer, 32, "%i", local_td->instance->loop);
  1665.     local_td->argv[argc++] = strdup(buffer);
  1666.     local_td->argv[argc++] = strdup("-fixed-vo");
  1667.     base_argc = argc;
  1668. }
  1669.     }
  1671.     loop_count = local_td->instance->loop;
  1672.     if (DEBUG)
  1673. printf("----player thread: set loop_count to %in",loop_count);
  1674.     
  1675.     while (1) {
  1676. if (DEBUG)
  1677.     printf("----player thread: entering loop. loop_count = %in",loop_count);
  1679. pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock,
  1680.      (void *) &(local_td->instance->
  1681. playlist_mutex));
  1683. pthread_mutex_lock(&(local_td->instance->playlist_mutex));
  1685. //find a node to play
  1686. if (DEBUG)
  1687.     printf("----player thread: looking for node to playn");
  1689. listempty = 0;
  1690. local_list = local_td->list;
  1691. while (local_list != NULL) {
  1692.     if (DEBUG)
  1693. printf("----player thread: play = %i played = %i fname = %sn",local_list->play,local_list->played, local_list->fname);
  1694.     if (local_list->play && !(local_list->played)) {
  1695. break;
  1696.     }
  1697.     local_list = local_list->next;
  1698. }
  1700. if (local_list == NULL) {
  1701.     //nothing to play: will exit, unless we have loop
  1702.     // the -- is to countdown the loop
  1703.     if (DEBUG)
  1704. printf("----player thread: local_list is NULL loop_count = %in",loop_count);
  1706.        if (local_td->instance->loop != 0)
  1707. loop_count--;
  1709.     if (DEBUG)
  1710. printf("----player thread: loop_count = %i loop_single = %in",loop_count,loop_single);
  1711.     
  1712.     // we're gonna reset the playlist, because we are going to play it again
  1713.     if ((loop_count > 0) && (loop_single == 0) || (local_td->instance->loop == 0)) {
  1714. local_list = local_td->list;
  1715. while (local_list != NULL) {
  1716.     if (local_list->play)
  1717. local_list->played = 0;
  1718.     local_list = local_list->next;
  1719. }
  1721. // rescan again, find the first playable item from the top of the list.
  1722. local_list = local_td->list;
  1723. while (local_list != NULL) {
  1724.     if (local_list->play && !(local_list->played)) {
  1725. break;
  1726.     }
  1727.     local_list = local_list->next;
  1728. }
  1729.     }
  1730. }
  1732. local_td->instance->currentnode = local_list;
  1733. if (local_list == NULL) {
  1734.     if (DEBUG)
  1735. printf("----player thread: nothing on the list to playn");
  1736.     listempty = 1;
  1737.     local_mmsstream = 0;
  1738.     // update MediaCompleteWithError Callback with PLAYLIST EMPTY but only if we have not played anything
  1739.     if ((local_td->instance->mediaCompleteWithErrorCallback !=
  1740.  NULL) && (lasterror == -1)) {
  1741. if (DEBUG)
  1742.     printf("mediaCompleteWithError(before) = %sn",
  1743.    local_td->instance->
  1744.    mediaCompleteWithErrorCallback);
  1745. strlcpy(message,
  1746. local_td->instance->mediaCompleteWithErrorCallback,
  1747. 1024);
  1748. p = index(message, '(');
  1749. if (p == NULL) {
  1750.     p = message + strlen(message);
  1751. }
  1752. *p = '';
  1753. snprintf(buffer, 1024, "%s(%i);", message,
  1754.  ERROR_PLAYLIST_EMPTY);
  1755. NPN_MemFree(local_td->instance->
  1756.     mediaCompleteWithErrorCallback);
  1757. local_td->instance->mediaCompleteWithErrorCallback =
  1758.     (char *) NPN_MemAlloc(strlen(buffer));
  1759. strlcpy(local_td->instance->mediaCompleteWithErrorCallback,
  1760. buffer, strlen(buffer));
  1761. if (DEBUG)
  1762.     printf("mediaCompleteWithError(after) = %sn",
  1763.    local_td->instance->
  1764.    mediaCompleteWithErrorCallback);
  1765.     }
  1766. } else {
  1767.     //we have a node to play
  1768.     if (DEBUG)
  1769. printf("----player thread: chose url %sn",
  1770.        local_list->url);
  1771.     listempty = 0;
  1772.     snprintf(local_url, 1024, "%s", local_list->url);
  1773.     local_url[1023] = '';
  1774.     local_mmsstream = local_list->mmsstream;
  1775. }
  1776. if (local_td->instance->rtsp_use_http
  1777.     && strncmp(local_url, "rtsp://", 7) == 0)
  1778.     memcpy(local_url, "http://", 7);
  1780. pthread_mutex_unlock(&(local_td->instance->playlist_mutex));
  1781. pthread_cleanup_pop(0);
  1783. if (listempty == 1)
  1784.     break;
  1786. pthread_testcancel();
  1788. usefps = 0;
  1789. nomouseinput = local_td->instance->nomouseinput;
  1790. maybeplaylist = 0;
  1792. do {
  1794.     pthread_testcancel();
  1796.     tryagain = 0;
  1797.     argc = base_argc;
  1798.     while (argc < 50) {
  1799. if (local_td->argv[argc] != NULL)
  1800.     free(local_td->argv[argc]);
  1801. local_td->argv[argc++] = NULL;
  1802.     }
  1803.     argc = base_argc;
  1805.     unEscapeXML(local_url);
  1807.     if (DEBUG)
  1808. printf("----player thread: playing url: %sn", local_url);
  1809.     snprintf(message, 1024, _("Playing %s"), local_list->url);
  1810. #ifdef X_ENABLED
  1811.     DrawUI(local_td->w, local_td->instance, message, 0, -1);
  1812. #endif
  1813. #ifdef GTK_ENABLED
  1814.     snprintf(local_td->instance->lastmessage, 1024, "%s", message);
  1815.     g_idle_add(gtkgui_message, local_td->instance);
  1816. #endif
  1817.     pthread_cleanup_push((void (*)(void *))
  1818.  pthread_mutex_unlock,
  1819.  (void *) &(local_td->instance->
  1820.     playlist_mutex));
  1821.     pthread_mutex_lock(&(local_td->instance->playlist_mutex));
  1825.     // for rtsp streams we need to specify FPS
  1826.     if (usefps == 1) {
  1827. if (strncmp(local_list->url, "rtsp", 4) == 0) {
  1828.     local_td->argv[argc++] = strdup("-fps");
  1829.     local_td->argv[argc++] = strdup("30");
  1830. }
  1831. usefps = 0;
  1832.     }
  1834.     if (local_td->instance->rtsp_use_tcp == 1) {
  1835. if (strncmp(local_list->url, "rtsp", 4) == 0) {
  1836.     snprintf(buffer, 1024, "-rtsp-stream-over-tcp");
  1837.     local_td->argv[argc++] = strdup(buffer);
  1838. }
  1839.     }
  1841.     if (local_td->instance->useragent) {
  1842. snprintf(buffer, 1024, "-user-agent");
  1843. local_td->argv[argc++] = strdup(buffer);
  1844. snprintf(buffer, 1024, "%s",
  1845.  local_td->instance->useragent);
  1846. local_td->argv[argc++] = strdup(buffer);
  1847.     }
  1849.     if (nomouseinput) {
  1850. local_td->argv[argc++] = strdup("-nomouseinput");
  1851. //          } else {
  1852. //              nomouseinput = 0;
  1853.     }
  1855.     if (local_td->instance->starttime > 0) {
  1856. local_td->argv[argc++] = strdup("-ss");
  1857. snprintf(message, 1024, "%li",
  1858.  local_td->instance->starttime);
  1859. local_td->argv[argc++] = strdup(message);
  1860. local_td->instance->starttime = 0;
  1861.     }
  1864.     if (local_td->instance != NULL)
  1865. local_td->instance->mmsstream = local_list->mmsstream;
  1866.     if (local_list->mmsstream) {
  1867. #ifdef GTK_ENABLED
  1868. g_idle_add(gtkgui_updatebuttons, local_td->instance);
  1869. #endif
  1870. local_td->argv[argc++] = strdup("-cache");
  1871. snprintf(message, 1024, "%i",
  1872.  local_td->instance->cachesize);
  1873. local_td->argv[argc++] = strdup(message);
  1874.         if (DEBUG)
  1875. printf("pre local_url is %sn",local_url);
  1876. if (result != NULL) {
  1877. if (result->tryagain != TRYAGAIN_FALLBACK) {
  1878.     // mmsToHttp(local_url, local_list->url);
  1879. }
  1880. } else {
  1881.     if (DEBUG)
  1882. printf("result = nulln");
  1883.     // mmsToHttp(local_url, local_list->url);
  1884. }
  1885.         if (DEBUG)
  1886. printf("local_url is %sn",local_url);
  1887. local_td->argv[argc++] = strdup(local_url);
  1888. if (local_td->instance->keep_download) {
  1889.     snprintf(mmsplaylist, sizeof(mmsplaylist),
  1890.      "%s/playlist",
  1891.      local_td->instance->download_dir);
  1892.     playlist = fopen(mmsplaylist, "a");
  1893.     if (playlist != NULL) {
  1894. fprintf(playlist, "%sn", local_url);
  1895. fclose(playlist);
  1896.     }
  1897. }
  1898.     } else {
  1899. if (strlen(local_list->fname) == 0) {
  1900.     local_td->argv[argc++] = strdup("-cache");
  1901.     snprintf(message, 1024, "%i",
  1902.      local_td->instance->cachesize);
  1903.     local_td->argv[argc++] = strdup(message);
  1904.     if (local_list->playlist == 1 || maybeplaylist != 0) {
  1905. local_td->argv[argc++] = strdup("-playlist");
  1906.     }
  1907.     local_td->argv[argc++] = strdup(local_url);
  1908. } else {
  1909.     local_td->argv[argc++] = strdup("-nocache");
  1910.     if (local_list->playlist == 1 || maybeplaylist != 0)
  1911. local_td->argv[argc++] = strdup("-playlist");
  1912.     local_td->argv[argc++] = strdup(local_list->fname);
  1913. }
  1914.     }
  1917.     if (DEBUG) {
  1918. printf("----player thread: URL: %sn", local_url);
  1919.     }
  1921.     pthread_mutex_unlock(&(local_td->instance->playlist_mutex));
  1922.     pthread_cleanup_pop(0);
  1924.     pthread_testcancel();
  1926.     //start up download
  1927.     pthread_cleanup_push((void (*)(void *))
  1928.  pthread_mutex_unlock,
  1929.  (void *) &(local_td->instance->
  1930.     control_mutex));
  1931.     pthread_mutex_lock(&(local_td->instance->control_mutex));
  1933.     local_td->instance->player =
  1934. mypopen(local_td->argv, &(local_td->instance->pid),
  1935. &(local_td->instance->control),
  1936. local_td->instance);
  1937.     if (local_td->instance->player != NULL) {
  1938. local_td->instance->js_state = JS_STATE_PLAYING;
  1939.     }
  1941.     pthread_mutex_unlock(&(local_td->instance->control_mutex));
  1942.     pthread_cleanup_pop(0);
  1944.     if (result != NULL) {
  1945. lasterror = result->errorcode;
  1946. NPN_MemFree(result);
  1947. result = NULL;
  1948.     }
  1950.     local_td->instance->state = STATE_PLAYING;
  1951.     if (local_td->instance->player != NULL) {
  1953. assert(local_td->instance->control > 0);
  1955. // reset media counters
  1956. local_td->instance->mediaLength = 0.0;
  1957. local_td->instance->mediaPercent = 0;
  1959. result =
  1960.     playNode(local_td, local_list, local_url,
  1961.      local_mmsstream, &usefps, &nomouseinput,
  1962.      &maybeplaylist);
  1964. pthread_mutex_lock(&(local_td->instance->control_mutex));
  1965. local_td->instance->js_state = JS_STATE_TRANSITIONING;
  1966. pthread_mutex_unlock(&(local_td->instance->control_mutex));
  1968. if (DEBUG)
  1969.     printf
  1970. ("----player thread: playNode returned = %dn",
  1971.  result->retval);
  1973. pthread_testcancel();
  1974. assert(local_list != NULL);
  1976. local_td->instance->mediaPercent = 0;
  1977. #ifdef GTK_ENABLED
  1978. g_idle_add(gtkgui_drawMediaProgress, local_td->instance);
  1979. #endif
  1980. if (local_td->instance->targetplayer == 0) {
  1981.     local_td->instance->movie_height = 1;
  1982.     local_td->instance->movie_width = 1;
  1983. #ifdef GTK_ENABLED
  1984.     g_idle_add(gtkgui_resize, local_td->instance);
  1985.     g_idle_add(gtkgui_draw, local_td->instance);
  1986. #endif
  1987. }
  1988. // this cancels the download of this media
  1989. // if there are more than 1, saves bandwidth
  1990. // also prevents us from playing it again
  1991. pthread_mutex_lock(&(local_td->instance->playlist_mutex));
  1992. if (result->retval == 0) {
  1993.     if (local_list->mmsstream
  1994. && (result->errorcode == ERROR_QUIT)) {
  1995. local_list->played = 0;
  1996.     } else {
  1997. local_list->played = 1;
  1998.     }
  1999. }
  2000. pthread_mutex_unlock(&
  2001.      (local_td->instance->playlist_mutex));
  2003. assert(local_td->instance != NULL);
  2004. if (DEBUG)
  2005.     printf("----player thread: played = %i - %sn",local_list->played,local_list->fname);
  2007. //close the pipes to download
  2009. assert(local_td->instance->control > 0);
  2010. close(local_td->instance->control);
  2011. local_td->instance->control = -1;
  2013. assert(local_td->instance->player != NULL);
  2014. fclose(local_td->instance->player);
  2015. local_td->instance->player = NULL;
  2017. if (DEBUG)
  2018.     printf("----player thread: close donen");
  2020. local_td->instance->state = STATE_PLAYLIST_NEXT;
  2022.     }
  2023.     // update MediaCompleteWithError Callback
  2024.     if (local_td->instance->mediaCompleteWithErrorCallback != NULL) {
  2025. if (DEBUG)
  2026.     printf("mediaCompleteWithError(before) = %sn",
  2027.    local_td->instance->
  2028.    mediaCompleteWithErrorCallback);
  2029. strlcpy(message,
  2030. local_td->instance->mediaCompleteWithErrorCallback,
  2031. 1024);
  2032. p = index(message, '(');
  2033. if (p == NULL) {
  2034.     p = message + strlen(message);
  2035. }
  2036. *p = '';
  2037. snprintf(buffer, 1024, "%s(%i);", message,
  2038.  result->errorcode);
  2039. NPN_MemFree(local_td->instance->
  2040.     mediaCompleteWithErrorCallback);
  2041. local_td->instance->mediaCompleteWithErrorCallback =
  2042.     (char *) NPN_MemAlloc(strlen(buffer));
  2043. strlcpy(local_td->instance->mediaCompleteWithErrorCallback,
  2044. buffer, strlen(buffer));
  2045. if (DEBUG)
  2046.     printf("mediaCompleteWithError(after) = %sn",
  2047.    local_td->instance->
  2048.    mediaCompleteWithErrorCallback);
  2049.     }
  2051. } while (result->retval);
  2053. // if we are in a list of mmsstreams, then we need to stop 
  2055. if (DEBUG)
  2056.     printf("mmsstream = %i errorcode = %i n",
  2057.    local_list->mmsstream, result->errorcode);
  2059. if (local_list->mmsstream && (result->errorcode == ERROR_QUIT)) {
  2060.     if (DEBUG)
  2061. printf("breaking out of next item loopn");
  2062.     break;
  2063. }
  2064. local_td->instance->currentnode = NULL;
  2066. //if we get here, either the control pipes are closed
  2067. //  or they were never opened in the first place
  2069. if (DEBUG) {
  2070.     printf("----player thread: transitioning to next itemn");
  2071. }
  2073. pthread_mutex_lock(&(local_td->instance->control_mutex));
  2074. local_td->instance->js_state = JS_STATE_TRANSITIONING;
  2075. pthread_mutex_unlock(&(local_td->instance->control_mutex));
  2077. pthread_testcancel();
  2078. assert(local_td != NULL);
  2079. assert(local_td->instance != NULL);
  2080. pthread_testcancel();
  2083. // if we have media type that changes from video to audio 
  2084. // in X mode this will take care of that situation
  2085. local_td->instance->noredraw = 0;
  2087. /*
  2088.    assert(local_td->instance->state != STATE_PLAY_CANCELLED);
  2089.  */
  2090.     } // end main while loop
  2092.     if (DEBUG) {
  2093. printf("----player thread: nothing to playn");
  2094.     }
  2095. #ifdef GTK_ENABLED
  2096.     g_idle_add(gtkgui_stop, local_td->instance);
  2097.     // call media complete when we are done with the playlist
  2098.     if (local_td->instance->mediaCompleteCallback != NULL) {
  2099. g_idle_add(mediacallback, local_td->instance);
  2100.     }
  2101. #endif
  2102. #ifdef X_ENABLED
  2103.     if (local_td->instance->mediaCompleteCallback != NULL)
  2104. NPN_GetURL(local_td->instance->mInstance,
  2105.    local_td->instance->mediaCompleteCallback, "_self");
  2106.     if (local_td->instance->mediaCompleteWithErrorCallback != NULL)
  2107. NPN_GetURL(local_td->instance->mInstance,
  2108.    local_td->instance->mediaCompleteWithErrorCallback,
  2109.    "_self");
  2110. #endif
  2111. #ifdef GTK2_ENABLED
  2112.     if (GTK_IS_WIDGET(local_td->instance->src_event_box)) {
  2113. gtk_widget_show(local_td->instance->src_event_box);
  2114.     }
  2115. #endif
  2116.     if (DEBUG) {
  2117. printf("----player thread: callbacks completen");
  2118.     }
  2119.     // free all the data (command line parameters) that is used to start download
  2120.     pthread_mutex_lock(&(local_td->instance->control_mutex));
  2121.     local_td->instance->js_state = JS_STATE_UNDEFINED;
  2122.     argc = base_argc;
  2123.     while (argc < 50) {
  2124. if (local_td->argv[argc] != NULL)
  2125.     free(local_td->argv[argc]);
  2126. local_td->argv[argc++] = NULL;
  2127.     }
  2128.     pthread_mutex_unlock(&(local_td->instance->control_mutex));
  2129.     pthread_mutex_unlock(&(local_td->instance->playlist_cond_mutex));
  2130.     // since thread is dead, reset thread state variables.
  2131.     local_td->instance->threadsetup = 0;
  2132.     local_td->instance->threadlaunched = 0;
  2133.     local_td->instance->threadsignaled = 0;
  2135.     //once we get here, the thread is only allowed to access stack
  2136.     // variables and then exit (since another player thread may have
  2137.     // been started at this time).    
  2139.     if (DEBUG) {
  2140. printf("----player thread: normal exitn");
  2141.     }
  2142.     //pthread_exit(0);
  2144.     return NULL;
  2145. }