video.tex

linux TV 源码

}{
EBADF&           fd is not a valid open file descriptor \\
EINTERNAL &      Internal error, possibly in the communication with 
                        the DVB subsystem.\\
}


\ifunction{VIDEO\_FREEZE}{
  int ioctl(fd, int request = VIDEO\_FREEZE);}{
        This ioctl call suspends the live video stream being played. 
        Decoding and playing are frozen. It is then possible to restart 
        the decoding and playing process of the video stream using the
        VIDEO\_CONTINUE command. If VIDEO\_SOURCE\_MEMORY is selected in the
        ioctl call VIDEO\_SELECT\_SOURCE, the DVB subsystem will not decode 
        any more data until the ioctl call VIDEO\_CONTINUE or VIDEO\_PLAY is 
        performed.
}{
int fd & File descriptor returned by a previous call to open(). \\
int request &    Equals VIDEO\_FREEZE for this command. \\
}{
EBADF&           fd is not a valid open file descriptor \\
EINTERNAL &      Internal error, possibly in the communication with 
                        the DVB subsystem.\\
}

\ifunction{VIDEO\_CONTINUE}{
  int ioctl(fd, int request = VIDEO\_CONTINUE);}{
  This ioctl call restarts decoding and playing processes of the video
  stream which was played before a call to VIDEO\_FREEZE was made.
  }{
  int fd & File descriptor returned by a previous call to open(). \\
  int request &    Equals VIDEO\_CONTINUE for this command. \\
  }{
  EBADF&           fd is not a valid open file descriptor \\
  EINTERNAL &      Internal error, possibly in the communication with 
  the DVB subsystem.\\
  }


\ifunction{VIDEO\_SELECT\_SOURCE}{
  int ioctl(fd, int request = VIDEO\_SELECT\_SOURCE, video\_stream\_source\_t source);}{
  This ioctl call informs the video device which source shall be used 
  for the input data. The possible sources are demux or memory. If 
  memory is selected, the data is fed to the video device through 
  the write command.
  }{
  int fd     & File descriptor returned by a previous call to open().\\
  int request& Equals VIDEO\_SELECT\_SOURCE for this command. \\
  video\_stream\_source\_t source&Indicates which source shall be used for the Video stream.\\
  }{
  EBADF&       fd is not a valid open file descriptor \\
  EINTERNAL &  Internal error, possibly in the communication with the DVB subsystem.\\
}

\ifunction{VIDEO\_SET\_BLANK}{
  int ioctl(fd, int request = VIDEO\_SET\_BLANK, boolean mode);}{
        This ioctl call asks the Video Device to blank out the picture.
}{
int fd     & File descriptor returned by a previous call to open().\\
int request& Equals VIDEO\_SET\_BLANK for this command. \\
boolean mode&TRUE: Blank screen when stop.\\
            &FALSE:  Show last decoded frame.\\
}{
EBADF&      fd is not a valid open file descriptor \\
EINTERNAL & Internal error, possibly in the communication with the DVB subsystem.\\
EINVAL  &   Illegal input parameter\\
}

\ifunction{VIDEO\_GET\_STATUS}{
\label{videogetstatus}
  int ioctl(fd, int request = VIDEO\_GET\_STATUS, struct video\_status *status);}{
  This ioctl call asks the Video Device to return the current status of the device.
  }{
  int fd     & File descriptor returned by a previous call to open().\\
  int request& Equals VIDEO\_GET\_STATUS for this command.\\
  struct video\_status *status & Returns the current status of the Video Device.\\
}{
EBADF&      fd is not a valid open file descriptor \\
EINTERNAL & Internal error, possibly in the communication with the DVB subsystem.\\
EFAULT  &                status points to invalid address\\
}

\ifunction{VIDEO\_GET\_EVENT}{
\label{videogetevent}
  int ioctl(fd, int request = VIDEO\_GET\_EVENT, struct video\_event *ev);}{
        This ioctl call returns an event of type video\_event if available.
        If an event is not available, the behavior depends on whether the device is in
        blocking or non-blocking mode.  In the latter case, the call fails immediately
        with errno set to EWOULDBLOCK. In the former case, the call blocks until an 
        event becomes available.
        The standard Linux poll() and/or select() system calls can be used with the 
        device file descriptor to watch for new events.  For select(), the file 
        descriptor should be included in the exceptfds argument, and for poll(), 
        POLLPRI should be specified as the wake-up condition.
        Read-only permissions are sufficient for this ioctl call.
  }{
  int fd     & File descriptor returned by a previous call to open().\\
  int request& Equals VIDEO\_GET\_EVENT for this command.\\
  struct video\_event *ev & Points to the location where the event, if any, is
                                to be stored.\\
}{
EBADF  &  fd is not a valid open file descriptor \\
EFAULT &  ev points to invalid address \\
EWOULDBLOCK & There is no event pending, and the device is in non-blocking mode.\\
EOVERFLOW & \\
&Overflow in event queue - one or more events were lost.\\
}

\ifunction{VIDEO\_SET\_DISPLAY\_FORMAT}{
\label{videosetdisplayformat}
  int ioctl(fd, int request = VIDEO\_SET\_DISPLAY\_FORMAT, video\_display\_format\_t format);}{
  This ioctl call asks the Video Device to select the video format to be applied
  by the MPEG chip on the video.
  }{
  int fd      & File descriptor returned by a previous call to open().\\
  int request & Equals  VIDEO\_SET\_DISPLAY\_FORMAT for this command.\\
  video\_display\_format\_t format & Selects the video format to be used.\\
  }{
  EBADF&      fd is not a valid open file descriptor \\
  EINTERNAL & Internal error.\\
  EINVAL & Illegal parameter format.\\
}

\ifunction{VIDEO\_STILLPICTURE}{
  int ioctl(fd, int request = VIDEO\_STILLPICTURE, struct video\_still\_picture *sp);}{
  This ioctl call asks the Video Device to display a still picture (I-frame). 
  The input data shall contain an I-frame. If the pointer is NULL, then the 
  current displayed still picture is blanked.
  }{
  int fd      & File descriptor returned by a previous call to open().\\
  int request & Equals VIDEO\_STILLPICTURE for this command.\\
  struct video\_still\_picture *sp& 
  Pointer to a location where an I-frame and size is stored.\\
  }{
  EBADF&      fd is not a valid open file descriptor \\
  EINTERNAL & Internal error.\\
  EFAULT & sp points to an invalid iframe.\\
}

\ifunction{VIDEO\_FAST\_FORWARD}{
  int ioctl(fd, int request = VIDEO\_FAST\_FORWARD, int nFrames);}{
  This ioctl call asks the Video Device to skip decoding of N number of I-frames.
  This call can only be used if VIDEO\_SOURCE\_MEMORY is selected.
  }{
  int fd      & File descriptor returned by a previous call to open().\\
  int request & Equals VIDEO\_FAST\_FORWARD for this command.\\
  int nFrames & The number of frames to skip.\\
  }{
  EBADF&      fd is not a valid open file descriptor \\
  EINTERNAL & Internal error.\\
  EPERM & Mode VIDEO\_SOURCE\_MEMORY not selected.\\
  EINVAL & Illegal parameter format.\\
}

\ifunction{VIDEO\_SLOWMOTION}{
  int ioctl(fd, int request = VIDEO\_SLOWMOTION, int nFrames);}{
  This ioctl call asks the video device to repeat decoding frames N 
  number of times.
  This call can only be used if VIDEO\_SOURCE\_MEMORY is selected.
  }{
  int fd      & File descriptor returned by a previous call to open().\\
  int request & Equals VIDEO\_SLOWMOTION for this command.\\
  int nFrames & The number of times to repeat each frame.\\
  }{
  EBADF&      fd is not a valid open file descriptor \\
  EINTERNAL & Internal error.\\
  EPERM & Mode VIDEO\_SOURCE\_MEMORY not selected.\\
  EINVAL & Illegal parameter format.\\
}

\ifunction{VIDEO\_GET\_CAPABILITIES}{
  int ioctl(fd, int request = VIDEO\_GET\_CAPABILITIES, unsigned int *cap);}{
  This ioctl call asks the video device about its decoding capabilities.
  On success it returns and integer which has bits set according to the
  defines in section \ref{videocaps}.
  }{
  int fd      & File descriptor returned by a previous call to open().\\
  int request & Equals VIDEO\_GET\_CAPABILITIES for this command.\\
  unsigned int *cap    & Pointer to a location where to store the 
  capability information.\\
  }{
  EBADF& fd is not a valid open file descriptor \\
  EFAULT & cap points to an invalid iframe.\\
}

\ifunction{VIDEO\_SET\_ID}{
  int ioctl(int fd, int request = VIDEO\_SET\_ID, int id);}{
  This ioctl selects which sub-stream is to be decoded if a program or
  system stream is sent to the video device.
  }{
  int fd & File descriptor returned by a previous call to open().\\
  int request & Equals VIDEO\_SET\_ID for this command.\\
  int id& video sub-stream id
  }{
  EBADF&      fd is not a valid open file descriptor.\\
  EINTERNAL & Internal error.\\
  EINVAL & Invalid sub-stream id.
}

\ifunction{VIDEO\_CLEAR\_BUFFER}{
  int ioctl(fd, int request = VIDEO\_CLEAR\_BUFFER);}{
  This ioctl call clears all video buffers in the driver and 
  in the decoder hardware.
  }{
  int fd      & File descriptor returned by a previous call to open().\\
  int request & Equals VIDEO\_CLEAR\_BUFFER for this command.\\
  }{
  EBADF& fd is not a valid open file descriptor \\
}

\ifunction{VIDEO\_SET\_STREAMTYPE}{
  int ioctl(fd, int request = VIDEO\_SET\_STREAMTYPE, int type);}{
  This ioctl tells the driver which kind of stream to expect 
  being written to it. If this call is not used the default of video PES
  is used. Some drivers might not support this call and always expect PES.
  }{
  int fd      & File descriptor returned by a previous call to open().\\
  int request & Equals VIDEO\_SET\_STREAMTYPE for this command.\\
  int type & stream type\\
  }{
  EBADF& fd is not a valid open file descriptor \\
  EINVAL& type is not a valid or supported stream type.\\
}

\ifunction{VIDEO\_SET\_FORMAT}{
\label{videosetformat}
  int ioctl(fd, int request = VIDEO\_SET\_FORMAT, video\_format\_t format);
}{
  This ioctl sets the screen format (aspect ratio) of the connected
  output device (TV) so that the output of the decoder can 
  be adjusted accordingly.
  }{
  int fd      & File descriptor returned by a previous call to open().\\
  int request & Equals VIDEO\_SET\_FORMAT for this command.\\
  video\_format\_t format& video format of TV as defined in section \ref{videoformat}.\\
  }{
  EBADF& fd is not a valid open file descriptor \\
  EINVAL& format is not a valid video format.\\
}

\ifunction{VIDEO\_SET\_SYSTEM}{
\label{videosetsystem}
  int ioctl(fd, int request = VIDEO\_SET\_SYSTEM , video\_system\_t system);
}{
  This ioctl sets the television output format. The format (see section
  \ref{videosys}) may vary from the color format of the displayed MPEG
  stream. If the hardware is not able to display the requested format
  the call will return an error.
}{
  int fd      & File descriptor returned by a previous call to open().\\
  int request & Equals VIDEO\_SET\_FORMAT for this command.\\
  video\_system\_t system& video system of TV output.\\
}{
  EBADF& fd is not a valid open file descriptor \\
  EINVAL& system is not a valid or supported video system.\\
}

\ifunction{VIDEO\_SET\_HIGHLIGHT}{
\label{videosethighlight}
  int ioctl(fd, int request = VIDEO\_SET\_HIGHLIGHT ,video\_highlight\_t *vhilite) 
}{
  This ioctl sets the SPU highlight information for the menu access of
  a DVD.
}{
  int fd      & File descriptor returned by a previous call to open().\\
  int request & Equals VIDEO\_SET\_HIGHLIGHT for this command.\\
  video\_highlight\_t *vhilite& SPU Highlight information according to
  section \ref{vhilite}.\\
}{
  EBADF& fd is not a valid open file descriptor. \\
  EINVAL& input is not a valid highlight setting.\\
}


\ifunction{VIDEO\_SET\_SPU}{
\label{videosetspu}
  int ioctl(fd, int request = VIDEO\_SET\_SPU , video\_spu\_t *spu)
}{
  This ioctl activates or deactivates SPU decoding in a DVD input
  stream. It can only be used, if the driver is able to handle a DVD
  stream.
}{
  int fd      & File descriptor returned by a previous call to open().\\
  int request & Equals VIDEO\_SET\_SPU for this command.\\
  video\_spu\_t *spu& SPU decoding (de)activation and subid setting
  according to section \ref{videospu}.\\
}{
  EBADF& fd is not a valid open file descriptor \\
  EINVAL& input is not a valid spu setting or driver cannot handle SPU.\\
}


\ifunction{VIDEO\_SET\_SPU\_PALETTE}{
\label{videosetspupalette}
  int ioctl(fd, int request = VIDEO\_SET\_SPU\_PALETTE ,video\_spu\_palette\_t *palette )
}{
  This ioctl sets the SPU color palette.
}{
  int fd      & File descriptor returned by a previous call to open().\\
  int request & Equals VIDEO\_SET\_SPU\_PALETTE for this command.\\
  video\_spu\_palette\_t *palette& SPU palette according to section \ref{vspupal}.\\
}{
  EBADF& fd is not a valid open file descriptor \\
  EINVAL& input is not a valid palette or driver doesn't handle SPU.\\
}



\ifunction{VIDEO\_GET\_NAVI}{
\label{videosetnavi}
  int ioctl(fd, int request = VIDEO\_GET\_NAVI , video\_navi\_pack\_t *navipack)
}{
  This ioctl returns navigational information from the DVD stream. This is
  especially needed if an encoded stream has to be decoded by the hardware.
}{
  int fd      & File descriptor returned by a previous call to open().\\
  int request & Equals VIDEO\_GET\_NAVI for this command.\\
  video\_navi\_pack\_t *navipack& PCI or DSI pack (private stream 2)
  according to section \ref{videonavi}.\\
}{
  EBADF& fd is not a valid open file descriptor \\
  EFAULT& driver is not able to return navigational information\\
}


\ifunction{VIDEO\_SET\_ATTRIBUTES}{
\label{videosetattributes}
  int ioctl(fd, int request = VIDEO\_SET\_ATTRIBUTE ,video\_attributes\_t
  vattr) 
}{
  This ioctl is intended for DVD playback and allows you to set
  certain information about the stream. Some hardware may not need
  this information, but the call also tells the hardware to prepare
  for DVD playback.
}{
  int fd      & File descriptor returned by a previous call to open().\\
  int request & Equals VIDEO\_SET\_ATTRIBUTE for this command.\\
  video\_attributes\_t vattr& video attributes according to section \ref{vattrib}.\\
}{
  EBADF& fd is not a valid open file descriptor \\
  EINVAL& input is not a valid attribute setting.\\
}


%%% Local Variables: 
%%% mode: latex
%%% TeX-master: "dvbapi"
%%% End: