access.c

来自「VLC媒体播放程序」· C语言 代码 · 共 1,611 行 · 第 1/4 页

          tp += strlen(_("Entry"));
          break;
        case VCDINFO_ITEM_TYPE_SEGMENT:
          strncat(tp, _("Segment"), TEMP_STR_LEN-(tp-temp_str));
          tp += strlen(_("Segment"));
          break;
        case VCDINFO_ITEM_TYPE_LID:
          strncat(tp, _("List ID"), TEMP_STR_LEN-(tp-temp_str));
          tp += strlen(_("List ID"));
          break;
        case VCDINFO_ITEM_TYPE_SPAREID2:
          strncat(tp, _("Navigation"), TEMP_STR_LEN-(tp-temp_str));
          tp += strlen(_("Navigation"));
          break;
        default:
          /* What to do? */
          ;
        }
        saw_control_prefix = false;
      }
      break;

    case 'L':
      if (vcdplayer_pbc_is_on(p_vcd)) {
        char num_str[40];
        sprintf(num_str, "%s %d", _("List ID"), p_vcd->cur_lid);
        strncat(tp, num_str, TEMP_STR_LEN-(tp-temp_str));
        tp += strlen(num_str);
      }
      saw_control_prefix = false;
      break;

    case 'M':
      add_format_str_info(mrl);
      break;

    case 'N':
      add_format_num_info(itemid->num, "%d");
      break;

    case 'p':
      add_format_str_info(vcdinfo_get_preparer_id(p_vcd->vcd));
      break;

    case 'P':
      add_format_str_info(vcdinfo_get_publisher_id(p_vcd->vcd));
      break;

    case 'S':
      if ( VCDINFO_ITEM_TYPE_SEGMENT==itemid->type ) {
        char seg_type_str[10];

        sprintf(seg_type_str, " %s",
                vcdinfo_video_type2str(p_vcd->vcd, itemid->num));
        strncat(tp, seg_type_str, TEMP_STR_LEN-(tp-temp_str));
        tp += strlen(seg_type_str);
      }
      saw_control_prefix = false;
      break;

    case 'T':
      add_format_num_info(p_vcd->cur_track, "%d");
      break;

    case 'V':
      add_format_str_info(vcdinfo_get_volumeset_id(p_vcd->vcd));
      break;

    case 'v':
      add_format_str_info(vcdinfo_get_volume_id(p_vcd->vcd));
      break;

    default:
      *tp++ = '%';
      *tp++ = format_str[i];
      saw_control_prefix = false;
    }
  }
  return strdup(temp_str);
}

static void
VCDCreatePlayListItem(const input_thread_t *p_input,
                      thread_vcd_data_t *p_vcd,
                      playlist_t *p_playlist,
                      const vcdinfo_itemid_t *itemid,
                      char *psz_mrl, int psz_mrl_max,
                      const char *psz_source, int playlist_operation,
                      int i_pos)
{
  char *p_author;
  char *p_title;
  char c_type;

  switch(itemid->type) {
  case VCDINFO_ITEM_TYPE_TRACK:
    c_type='T';
    break;
  case VCDINFO_ITEM_TYPE_SEGMENT:
    c_type='S';
    break;
  case VCDINFO_ITEM_TYPE_LID:
    c_type='P';
    break;
  case VCDINFO_ITEM_TYPE_ENTRY:
    c_type='E';
    break;
  default:
    c_type='?';
    break;
  }

  snprintf(psz_mrl, psz_mrl_max, "%s%s@%c%u", VCD_MRL_PREFIX, psz_source,
           c_type, itemid->num);

  p_title =
    VCDFormatStr( p_input, p_vcd,
		  config_GetPsz( p_input, MODULE_STRING "-title-format" ),
		  psz_mrl, itemid );
  
  playlist_Add( p_playlist, psz_mrl, p_title, playlist_operation, i_pos );

  p_author =
    VCDFormatStr( p_input, p_vcd,
		  config_GetPsz( p_input, MODULE_STRING "-author-format" ),
		  psz_mrl, itemid );

  if( i_pos == PLAYLIST_END ) i_pos = p_playlist->i_size - 1;
  playlist_AddInfo(p_playlist, i_pos, _("General"), _("Author"), "%s",
		   p_author);
}

static int
VCDFixupPlayList( input_thread_t *p_input, thread_vcd_data_t *p_vcd,
                  const char *psz_source, vcdinfo_itemid_t *itemid,
                  bool play_single_item )
{
  unsigned int i;
  playlist_t * p_playlist;
  char       * psz_mrl;
  unsigned int psz_mrl_max = strlen(VCD_MRL_PREFIX) + strlen(psz_source) +
    strlen("@T") + strlen("100") + 1;

  psz_mrl = malloc( psz_mrl_max );

  if( psz_mrl == NULL )
    {
      msg_Warn( p_input, "out of memory" );
      return -1;
    }

  p_playlist = (playlist_t *) vlc_object_find( p_input, VLC_OBJECT_PLAYLIST,
                                               FIND_ANYWHERE );
  if( !p_playlist )
    {
      msg_Warn( p_input, "can't find playlist" );
      free(psz_mrl);
      return -1;
    }

  InformationCreate( p_input );

  if ( play_single_item ) 
    {
    /* May fill out more information when the playlist user interface becomes
       more mature.
     */
    VCDCreatePlayListItem(p_input, p_vcd, p_playlist, itemid,
                          psz_mrl, psz_mrl_max, psz_source, PLAYLIST_REPLACE,
                          p_playlist->i_index);

    } 
  else 
    {
    vcdinfo_itemid_t list_itemid;
    list_itemid.type=VCDINFO_ITEM_TYPE_ENTRY;

    playlist_Delete( p_playlist, p_playlist->i_index);

    for( i = 0 ; i < p_vcd->num_entries ; i++ )
      {
        list_itemid.num=i;
        VCDCreatePlayListItem(p_input, p_vcd, p_playlist, &list_itemid,
                              psz_mrl, psz_mrl_max, psz_source,
                              PLAYLIST_APPEND, PLAYLIST_END);
      }

    playlist_Command( p_playlist, PLAYLIST_GOTO, 0 );

  }

  vlc_object_release( p_playlist );
  free(psz_mrl);
  return 0;
}

/*****************************************************************************
 * Public routines.
 *****************************************************************************/
int
E_(DebugCallback)   ( vlc_object_t *p_this, const char *psz_name,
                      vlc_value_t oldval, vlc_value_t val, void *p_data )
{
  thread_vcd_data_t *p_vcd;

  if (NULL == p_vcd_input) return VLC_EGENERIC;

  p_vcd = (thread_vcd_data_t *)p_vcd_input->p_access_data;

  if (p_vcd->i_debug & (INPUT_DBG_CALL|INPUT_DBG_EXT)) {
    msg_Dbg( p_vcd_input, "Old debug (x%0x) %d, new debug (x%0x) %d",
             p_vcd->i_debug, p_vcd->i_debug, val.i_int, val.i_int);
  }
  p_vcd->i_debug = val.i_int;
  return VLC_SUCCESS;
}

/*****************************************************************************
  Open: open VCD.
  read in meta-information about VCD: the number of tracks, segments,
  entries, size and starting information. Then set up state variables so
  that we read/seek starting at the location specified.

  On success we return VLC_SUCCESS, on memory exhausted VLC_ENOMEM,
  and VLC_EGENERIC for some other error.
 *****************************************************************************/
int
E_(Open) ( vlc_object_t *p_this )
{
    input_thread_t *        p_input = (input_thread_t *)p_this;
    thread_vcd_data_t *     p_vcd;
    char *                  psz_source;
    vcdinfo_itemid_t        itemid;
    bool                    b_play_ok;
    bool                    play_single_item = false;

    p_input->pf_read        = VCDRead;
    p_input->pf_seek        = VCDSeek;
    p_input->pf_set_area    = VCDSetArea;
    p_input->pf_set_program = VCDSetProgram;

    p_vcd = malloc( sizeof(thread_vcd_data_t) );

    if( p_vcd == NULL )
    {
        LOG_ERR ("out of memory" );
        return VLC_ENOMEM;
    }

    p_input->p_access_data = (void *)p_vcd;
    p_vcd->i_debug         = config_GetInt( p_this, MODULE_STRING "-debug" );
    p_vcd->in_still        = false;
    p_vcd->play_item.type  = VCDINFO_ITEM_TYPE_NOTFOUND;

    /* Set where to log errors messages from libcdio. */
    p_vcd_input = (input_thread_t *)p_this;
    cdio_log_set_handler ( cdio_log_handler );
    vcd_log_set_handler ( vcd_log_handler );

    psz_source = VCDParse( p_input, &itemid, &play_single_item );

    if ( NULL == psz_source )
    {
      free( p_vcd );
      return( VLC_EGENERIC );
    }

    dbg_print( (INPUT_DBG_CALL|INPUT_DBG_EXT), "source: %s: mrl: %s",
               psz_source, p_input->psz_name );

    p_vcd->p_segments = NULL;
    p_vcd->p_entries  = NULL;

    /* set up input  */
    p_input->i_mtu = VCD_DATA_ONCE;

    vlc_mutex_lock( &p_input->stream.stream_lock );

    /* If we are here we can control the pace... */
    p_input->stream.b_pace_control = 1;

    p_input->stream.b_seekable = 1;
    p_input->stream.p_selected_area->i_size = 0;
    p_input->stream.p_selected_area->i_tell = 0;

    vlc_mutex_unlock( &p_input->stream.stream_lock );

    if( !(p_vcd->vcd = vcd_Open( p_this, psz_source )) )
    {
        msg_Warn( p_input, "could not open %s", psz_source );
        goto err_exit;
    }

    p_vcd->b_svd= vcdinfo_get_tracksSVD(p_vcd->vcd);;
    
    /* Get track information. */
    p_vcd->num_tracks = ioctl_GetTracksMap( VLC_OBJECT(p_input),
                                            vcdinfo_get_cd_image(p_vcd->vcd),
                                            &p_vcd->p_sectors );
    if( p_vcd->num_tracks < 0 )
        LOG_ERR ("unable to count tracks" );
    else if( p_vcd->num_tracks <= 1 )
        LOG_ERR ("no movie tracks found" );
    if( p_vcd->num_tracks <= 1)
    {
        vcdinfo_close( p_vcd->vcd );
        goto err_exit;
    }

    /* Set stream and area data */
    vlc_mutex_lock( &p_input->stream.stream_lock );

    /* Initialize ES structures */
    input_InitStream( p_input, sizeof( stream_ps_data_t ) );

    /* disc input method */
    p_input->stream.i_method = INPUT_METHOD_VCD;

    p_input->stream.i_area_nb = 1;


    /* Initialize segment information. */
    VCDSegments( p_input );

    /* Initialize track area information. */
    VCDTracks( p_input );

    if( VCDEntryPoints( p_input ) < 0 )
    {
        msg_Warn( p_input, "could not read entry points, will not use them" );
        p_vcd->b_valid_ep = false;
    }

    if( VCDLIDs( p_input ) < 0 )
    {
        msg_Warn( p_input, "could not read entry LIDs" );
    }

    b_play_ok = (VLC_SUCCESS == VCDPlay( p_input, itemid ));

    vlc_mutex_unlock( &p_input->stream.stream_lock );

    if ( ! b_play_ok ) {
      vcdinfo_close( p_vcd->vcd );
      goto err_exit;
    }

    if( !p_input->psz_demux || !*p_input->psz_demux )
    {
#if FIXED
      p_input->psz_demux = "vcdx";
#else
      p_input->psz_demux = "ps";
#endif
    }

    p_vcd->p_intf = intf_Create( p_input, "vcdx" );
    p_vcd->p_intf->b_block = VLC_FALSE;
    intf_RunThread( p_vcd->p_intf );

    if (play_single_item)
      VCDFixupPlayList( p_input, p_vcd, psz_source, &itemid, play_single_item );

    free( psz_source );

    return VLC_SUCCESS;
 err_exit:
    free( psz_source );
    free( p_vcd );
    return VLC_EGENERIC;
}

/*****************************************************************************
 * Close: closes VCD releasing allocated memory.
 *****************************************************************************/
void
E_(Close) ( vlc_object_t *p_this )
{
    input_thread_t *   p_input = (input_thread_t *)p_this;
    thread_vcd_data_t *p_vcd = (thread_vcd_data_t *)p_input->p_access_data;

    dbg_print( (INPUT_DBG_CALL|INPUT_DBG_EXT), "VCDClose" );
    vcdinfo_close( p_vcd->vcd );

    free( p_vcd->p_entries );
    free( p_vcd->p_segments );
    free( p_vcd->p_sectors );

    /* For reasons that are a mystery to me we don't have to deal with
       stopping, and destroying the p_vcd->p_intf thread. And if we do
       it causes problems upstream.
     */
    if( p_vcd->p_intf != NULL )
    {
        p_vcd->p_intf = NULL;
    }

    free( p_vcd );
    p_input->p_access_data = NULL;
    p_vcd_input = NULL;
}