diff options
Diffstat (limited to 'softhddev.c')
| -rw-r--r-- | softhddev.c | 808 |
1 files changed, 808 insertions, 0 deletions
diff --git a/softhddev.c b/softhddev.c new file mode 100644 index 0000000..2bce10d --- /dev/null +++ b/softhddev.c @@ -0,0 +1,808 @@ +/// +/// @file softhddev.c @brief A software HD device plugin for VDR. +/// +/// Copyright (c) 2011 by Johns. All Rights Reserved. +/// +/// Contributor(s): +/// +/// License: AGPLv3 +/// +/// This program is free software: you can redistribute it and/or modify +/// it under the terms of the GNU Affero General Public License as +/// published by the Free Software Foundation, either version 3 of the +/// License. +/// +/// This program is distributed in the hope that it will be useful, +/// but WITHOUT ANY WARRANTY; without even the implied warranty of +/// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +/// GNU Affero General Public License for more details. +/// +/// $Id$ +////////////////////////////////////////////////////////////////////////////// + +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> + +#include <stdio.h> +#include <stdint.h> +#include <unistd.h> + +#include <libintl.h> +#define _(str) gettext(str) ///< gettext shortcut +#define _N(str) str ///< gettext_noop shortcut + +#include <libavcodec/avcodec.h> + +#include "misc.h" +#include "softhddev.h" + +#include "audio.h" +#include "video.h" +#include "codec.h" + +#define DEBUG + +////////////////////////////////////////////////////////////////////////////// +// Audio +////////////////////////////////////////////////////////////////////////////// + +static AudioDecoder *MyAudioDecoder; ///< audio decoder +static enum CodecID AudioCodecID; ///< current codec id + +extern void AudioTest(void); // FIXME: + +/** +** Play audio packet. +** +** @param data data of exactly one complete PES packet +** @param size size of PES packet +** @param id PES packet type +*/ +void PlayAudio(const uint8_t * data, int size, uint8_t id) +{ + int n; + AVPacket avpkt[1]; + + // PES header 0x00 0x00 0x01 ID + // ID 0xBD 0xC0-0xCF + + // channel switch: SetAudioChannelDevice: SetDigitalAudioDevice: + + // Detect audio code + // MPEG-PS mp2 MPEG1, MPEG2, AC3 + + if (size < 9) { + Error("[softhddev] invalid audio packet\n"); + return; + } + + avpkt->pts = AV_NOPTS_VALUE; + avpkt->dts = AV_NOPTS_VALUE; + if (data[7] & 0x80) { + avpkt->pts = + (int64_t) (data[9] & 0x0E) << 29 | data[10] << 22 | (data[11] & + 0xFE) << 15 | data[12] << 7 | (data[13] & 0xFE) >> 1; + // Debug(3, "audio: pts %ld\n", avpkt->pts); + } + if (data[7] & 0x40) { + avpkt->dts = + (int64_t) (data[14] & 0x0E) << 29 | data[15] << 22 | (data[16] & + 0xFE) << 15 | data[17] << 7 | (data[18] & 0xFE) >> 1; + Debug(3, "audio: dts %ld\n", avpkt->dts); + } + + n = data[8]; // header size + data += 9 + n; + size -= 9 + n; // skip pes header + if (size <= 0) { + Error("[softhddev] invalid audio packet\n"); + return; + } + // Syncword - 0x0B77 + if (data[0] == 0x0B && data[1] == 0x77) { + if (!MyAudioDecoder) { + MyAudioDecoder = CodecAudioNewDecoder(); + AudioCodecID = CODEC_ID_NONE; + } + if (AudioCodecID != CODEC_ID_AC3) { + Debug(3, "[softhddev]%s: AC-3 %d\n", __FUNCTION__, id); + CodecAudioClose(MyAudioDecoder); + CodecAudioOpen(MyAudioDecoder, NULL, CODEC_ID_AC3); + AudioCodecID = CODEC_ID_AC3; + } + // Syncword - 0xFFFC - 0xFFFF + } else if (data[0] == 0xFF && (data[1] & 0xFC) == 0xFC) { + if (!MyAudioDecoder) { + MyAudioDecoder = CodecAudioNewDecoder(); + AudioCodecID = CODEC_ID_NONE; + } + if (AudioCodecID != CODEC_ID_MP2) { + Debug(3, "[softhddev]%s: MP2 %d\n", __FUNCTION__, id); + CodecAudioClose(MyAudioDecoder); + CodecAudioOpen(MyAudioDecoder, NULL, CODEC_ID_MP2); + AudioCodecID = CODEC_ID_MP2; + } + } else { + // no start package + // FIXME: Nick/Viva sends this shit, need to find sync in packet + // FIXME: otherwise it takes too long until sound appears + if (AudioCodecID == CODEC_ID_NONE) { + Debug(3, "[softhddev]%s: ??? %d\n", __FUNCTION__, id); + return; + } + } + + // no decoder or codec known + if (!MyAudioDecoder || AudioCodecID == CODEC_ID_NONE) { + return; + } + + av_init_packet(avpkt); + avpkt->data = (void *)data; + avpkt->size = size; + //memset(avpkt->data + avpkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE); + CodecAudioDecode(MyAudioDecoder, avpkt); +} + +/** +** Mute audio device. +*/ +void Mute(void) +{ + AudioSetVolume(0); +} + +/** +** Set volume of audio device. +** +** @param volume VDR volume (0 .. 255) +*/ +void SetVolumeDevice(int volume) +{ + AudioSetVolume((volume * 100) / 255); +} + +////////////////////////////////////////////////////////////////////////////// +// Video +////////////////////////////////////////////////////////////////////////////// + +#include <alsa/iatomic.h> // portable atomic_t + +uint32_t VideoSwitch; +static int NewVideoStream; ///< new video stream +static VideoDecoder *MyVideoDecoder; ///< video decoder +static enum CodecID VideoCodecID; ///< current codec id + +static const char *X11DisplayName; ///< x11 display name +static volatile int Usr1Signal; ///< true got usr1 signal + + /// video PES buffer default size +#define VIDEO_BUFFER_SIZE (512 * 1024) +#define VIDEO_PACKET_MAX 128 ///< max number of video packets + /// video PES packet ring buffer +static AVPacket VideoPacketRb[VIDEO_PACKET_MAX]; +static int VideoPacketWrite; ///< write pointer +static int VideoPacketRead; ///< read pointer +static atomic_t VideoPacketsFilled; ///< how many of the buffer is used +static int VideoMaxPacketSize; ///< biggest used packet buffer +static uint32_t VideoStartTick; ///< video start tick + +extern void VideoWakeup(void); ///< wakeup video handler + +/** +** Initialize video packet ringbuffer. +*/ +static void VideoPacketInit(void) +{ + int i; + AVPacket *avpkt; + + Debug(4, "[softhddev]: %s\n", __FUNCTION__); + + for (i = 0; i < VIDEO_PACKET_MAX; ++i) { + avpkt = &VideoPacketRb[i]; + // build a clean ffmpeg av packet + av_init_packet(avpkt); + avpkt->destruct = av_destruct_packet; + avpkt->data = av_malloc(VIDEO_BUFFER_SIZE); + if (!avpkt->data) { + Fatal(_("[softhddev]: out of memory\n")); + } + avpkt->size = VIDEO_BUFFER_SIZE; + avpkt->priv = NULL; + } + + atomic_set(&VideoPacketsFilled, 0); +} + +/** +** Place video data in packet ringbuffer. +*/ +static void VideoEnqueue(const void *data, int size) +{ + AVPacket *avpkt; + + // Debug(3, "video: enqueue %d\n", size); + + avpkt = &VideoPacketRb[VideoPacketWrite]; + if (avpkt->stream_index + size + FF_INPUT_BUFFER_PADDING_SIZE >= + avpkt->size) { + + Warning(_("video: packet buffer too small for %d\n"), + avpkt->stream_index + size + FF_INPUT_BUFFER_PADDING_SIZE); + + av_grow_packet(avpkt, + (size + FF_INPUT_BUFFER_PADDING_SIZE + VIDEO_BUFFER_SIZE / 2) + / (VIDEO_BUFFER_SIZE / 2)); + } +#ifdef DEBUG + if (!avpkt->stream_index) { // debug save time of first packet + avpkt->dts = GetMsTicks(); + } +#endif + if (!VideoStartTick) { // tick of first valid packet + VideoStartTick = GetMsTicks(); + } + + memcpy(avpkt->data + avpkt->stream_index, data, size); + avpkt->stream_index += size; + if (avpkt->stream_index > VideoMaxPacketSize) { + VideoMaxPacketSize = avpkt->stream_index; + Debug(3, "video: max used PES packet size: %d\n", VideoMaxPacketSize); + } +} + +/** +** Finish current packet advance to next. +*/ +static void VideoNextPacket(int codec_id) +{ + AVPacket *avpkt; + + avpkt = &VideoPacketRb[VideoPacketWrite]; + if (!avpkt->stream_index) { // ignore empty packets + if (codec_id == CODEC_ID_NONE) { + Debug(3, "video: possible stream change loss\n"); + } + return; + } + + if (atomic_read(&VideoPacketsFilled) >= VIDEO_PACKET_MAX - 1) { + // no free slot available drop last packet + Error(_("video: no empty slot in packet ringbuffer\n")); + avpkt->stream_index = 0; + if (codec_id == CODEC_ID_NONE) { + Debug(3, "video: possible stream change loss\n"); + } + return; + } + // clear area for decoder, always enough space allocated + memset(avpkt->data + avpkt->stream_index, 0, FF_INPUT_BUFFER_PADDING_SIZE); + avpkt->priv = (void *)(size_t) codec_id; + + // advance packet write + VideoPacketWrite = (VideoPacketWrite + 1) % VIDEO_PACKET_MAX; + atomic_inc(&VideoPacketsFilled); + + // intialize next package to use + avpkt = &VideoPacketRb[VideoPacketWrite]; + avpkt->stream_index = 0; + avpkt->pts = AV_NOPTS_VALUE; + avpkt->dts = AV_NOPTS_VALUE; + + VideoWakeup(); +} + +/** +** Decode from PES packet ringbuffer. +*/ +int VideoDecode(void) +{ + int filled; + AVPacket *avpkt; + int saved_size; + static int last_codec_id = CODEC_ID_NONE; + + filled = atomic_read(&VideoPacketsFilled); + //Debug(3, "video: decode %3d packets buffered\n", filled); + if (!filled) { + // Debug(3, "video: decode no packets buffered\n"); + return -1; + } + avpkt = &VideoPacketRb[VideoPacketRead]; + + // + // handle queued commands + // + switch ((int)(size_t) avpkt->priv) { + case CODEC_ID_NONE: + if (last_codec_id != CODEC_ID_NONE) { + last_codec_id = CODEC_ID_NONE; + CodecVideoClose(MyVideoDecoder); + goto skip; + } + break; + case CODEC_ID_MPEG2VIDEO: + if (last_codec_id != CODEC_ID_MPEG2VIDEO) { + last_codec_id = CODEC_ID_MPEG2VIDEO; + CodecVideoOpen(MyVideoDecoder, 0 ? "mpegvideo_vdpau" : NULL, + CODEC_ID_MPEG2VIDEO); + } + break; + case CODEC_ID_H264: + if (last_codec_id != CODEC_ID_H264) { + last_codec_id = CODEC_ID_H264; + CodecVideoOpen(MyVideoDecoder, 0 ? "h264video_vdpau" : NULL, + CODEC_ID_H264); + } + break; + default: + break; + } + + // avcodec_decode_video2 needs size + saved_size = avpkt->size; + avpkt->size = avpkt->stream_index; + avpkt->stream_index = 0; + + CodecVideoDecode(MyVideoDecoder, avpkt); + + avpkt->size = saved_size; + + skip: + // advance packet read + VideoPacketRead = (VideoPacketRead + 1) % VIDEO_PACKET_MAX; + atomic_dec(&VideoPacketsFilled); + + return 0; +} + +/** +** Flush video buffer. +*/ +void VideoFlushInput(void) +{ + // flush all buffered packets + while (atomic_read(&VideoPacketsFilled)) { + VideoPacketRead = (VideoPacketRead + 1) % VIDEO_PACKET_MAX; + atomic_dec(&VideoPacketsFilled); + } + VideoStartTick = 0; +} + +/** +** Wakeup video handler. +*/ +void VideoWakeup(void) +{ + int filled; + uint32_t now; + uint64_t delay; + + VideoDisplayHandler(); + return; + + filled = atomic_read(&VideoPacketsFilled); + if (!filled) { + Debug(3, "video: wakeup no packets buffered\n"); + return; + } + + now = GetMsTicks(); + if (filled < VIDEO_PACKET_MAX && VideoStartTick + 1000 > now) { + delay = AudioGetDelay() / 90; + if (delay < 100) { // no audio delay known + delay = 750; + } + delay -= 40; + if (VideoStartTick + delay > now) { + Debug(3, "video: %d packets %u/%lu delayed\n", filled, + (unsigned)(now - VideoStartTick), delay); + return; + } + } + + VideoDecode(); + +#if 0 + AVPacket *avpkt; + + while (filled) { + avpkt = &VideoPacketRb[VideoPacketRead]; + now = GetMsTicks(); + if (avpkt->dts + 500 > now) { + Debug(3, "video: %d packets %u delayed\n", filled, + (unsigned)(now - avpkt->dts)); + return; + } + filled = atomic_read(&VideoPacketsFilled); + } +#endif +} + +/** +** Try video start. +** +** Could be called, when already started. +*/ +static void StartVideo(void) +{ + VideoInit(X11DisplayName); + VideoOsdInit(); + if (!MyVideoDecoder) { + VideoHwDecoder *hw_decoder; + + if ((hw_decoder = VideoNewHwDecoder())) { + MyVideoDecoder = CodecVideoNewDecoder(hw_decoder); + VideoCodecID = CODEC_ID_NONE; + } + } + VideoPacketInit(); +} + +/** +** Play video packet. +** +** @param data data of exactly one complete PES packet +** @param size size of PES packet +** +** @note vdr sends incomplete packets, va-api h264 decoder only +** supports complete packets. +** We buffer here until we receive an complete PES Packet, which +** is no problem, the audio is always far behind us. +*/ +void PlayVideo(const uint8_t * data, int size) +{ + const uint8_t *check; + uint64_t pts; + int n; + + if (Usr1Signal) { // x11 server ready + Usr1Signal = 0; + StartVideo(); + } + if (!MyVideoDecoder) { // no x11 video started + return; + } + if (NewVideoStream) { + Debug(3, "video: new stream %d\n", GetMsTicks() - VideoSwitch); + VideoNextPacket(CODEC_ID_NONE); + VideoCodecID = CODEC_ID_NONE; + NewVideoStream = 0; + } + // must be a PES start code + if (data[0] || data[1] || data[2] != 0x01 || size < 9) { + Error(_("[softhddev] invalid PES video packet\n")); + return; + } + n = data[8]; // header size + // wrong size + if (size < 9 + n) { + Error(_("[softhddev] invalid video packet\n")); + return; + } + check = data + 9 + n; + + // FIXME: get pts/dts, when we need it + + pts = AV_NOPTS_VALUE; + if (data[7] & 0x80) { + pts = + (int64_t) (data[9] & 0x0E) << 29 | data[10] << 22 | (data[11] & + 0xFE) << 15 | data[12] << 7 | (data[13] & 0xFE) >> 1; + // Debug(3, "video: pts %ld\n", pts); + } + // FIXME: no valid mpeg2/h264 detection yet + + if (0) { + printf("%02x: %02x %02x %02x %02x %02x\n", data[6], check[0], check[1], + check[2], check[3], check[4]); + } + // PES_VIDEO_STREAM 0xE0 or PES start code + if ((data[6] & 0xC0) != 0x80 || (!check[0] && !check[1] + && check[2] == 0x1)) { + if (VideoCodecID == CODEC_ID_MPEG2VIDEO) { + VideoNextPacket(CODEC_ID_MPEG2VIDEO); + } else { + VideoCodecID = CODEC_ID_MPEG2VIDEO; + } + // Access Unit Delimiter + } else if (!check[0] && !check[1] && !check[2] && check[3] == 0x1 + && check[4] == 0x09) { + if (VideoCodecID == CODEC_ID_H264) { + VideoNextPacket(CODEC_ID_H264); + } else { + Debug(3, "video: h264 detected\n"); + VideoCodecID = CODEC_ID_H264; + } + } else { + // this happens when vdr sends incomplete packets + if (VideoCodecID == CODEC_ID_NONE) { + Debug(3, "video: not detected\n"); + return; + } + if (VideoCodecID == CODEC_ID_MPEG2VIDEO) { + // mpeg codec supports incomplete packages + VideoNextPacket(CODEC_ID_MPEG2VIDEO); + } + } + + // SKIP PES header + size -= 9 + n; + VideoEnqueue(check, size); +} + +////////////////////////////////////////////////////////////////////////////// + +/** +** Set play mode, called on channel switch. +*/ +void SetPlayMode(void) +{ + if (MyVideoDecoder) { + if (VideoCodecID != CODEC_ID_NONE) { + NewVideoStream = 1; + VideoSwitch = GetMsTicks(); + } + } + if (MyAudioDecoder) { + // FIXME: does this clear the audio ringbuffer? + CodecAudioClose(MyAudioDecoder); + AudioCodecID = CODEC_ID_NONE; + } +} + +////////////////////////////////////////////////////////////////////////////// +// OSD +////////////////////////////////////////////////////////////////////////////// + +/** +** Get OSD size and aspect. +*/ +void GetOsdSize(int *width, int *height, double *aspect) +{ + static char done; + + // FIXME: should be configured! + *width = 1920; + *height = 1080; + //*width = 768; + //*height = 576; + + *aspect = 16.0 / 9.0 / (double)*width * (double)*height; + + if (!done) { + Debug(3, "[softhddev]%s: %dx%d %g\n", __FUNCTION__, *width, *height, + *aspect); + done = 1; + } +} + +/** +** Close OSD. +*/ +void OsdClose(void) +{ + VideoOsdClear(); +} + +/** +** Draw an OSD pixmap. +*/ +void OsdDrawARGB(int x, int y, int height, int width, const uint8_t * argb) +{ + VideoOsdDrawARGB(x, y, height, width, argb); +} + +////////////////////////////////////////////////////////////////////////////// + +static char StartX11Server; ///< flag start the x11 server + +/** +** Return command line help string. +*/ +const char *CommandLineHelp(void) +{ + return " -a device\talsa audio device (fe. hw:0,0)\n" + " -d display\tdisplay of x11 server (f.e :0.0)\n" + " -g geometry\tx11 window geometry wxh+x+y\n" + " -x\tstart x11 server\n"; +} + +/** +** Process the command line arguments. +** +** @param argc number of arguments +** @param argv arguments vector +*/ +int ProcessArgs(int argc, char *const argv[]) +{ + // + // Parse arguments. + // + for (;;) { + switch (getopt(argc, argv, "-a:d:g:x")) { + case 'a': // audio device + AudioSetDevice(optarg); + continue; + case 'd': // x11 display name + X11DisplayName = optarg; + continue; + case 'g': // geometry + if (VideoSetGeometry(optarg) < 0) { + fprintf(stderr, + _ + ("Bad formated geometry please use: [=][<width>{xX}<height>][{+-}<xoffset>{+-}<yoffset>]\n")); + return 0; + } + continue; + case 'x': // x11 server + StartX11Server = 1; + continue; + case EOF: + break; + case '-': + fprintf(stderr, _("We need no long options\n")); + return 0; + case ':': + fprintf(stderr, _("Missing argument for option '%c'\n"), + optopt); + return 0; + default: + fprintf(stderr, _("Unkown option '%c'\n"), optopt); + return 0; + } + break; + } + while (optind < argc) { + fprintf(stderr, _("Unhandled argument '%s'\n"), argv[optind++]); + } + + return 1; +} + +////////////////////////////////////////////////////////////////////////////// +// Init/Exit +////////////////////////////////////////////////////////////////////////////// + +#include <sys/types.h> +#include <sys/wait.h> + +#define XSERVER_MAX_ARGS 512 ///< how many arguments support + +static const char *X11Server = "/usr/bin/X"; ///< default x11 server +static const char *X11ServerArguments; ///< default command arguments +static pid_t X11ServerPid; ///< x11 server pid + +/** +** USR1 signal handler. +** +** @param sig signal number +*/ +static void Usr1Handler(int __attribute__ ((unused)) sig) +{ + ++Usr1Signal; + + Debug(3, "x-setup: got signal usr1\n"); +} + +/** +** Start the X server +*/ +static void StartXServer(void) +{ + struct sigaction usr1; + pid_t pid; + const char *sval; + const char *args[XSERVER_MAX_ARGS]; + int argn; + char *buf; + + // X server + if (X11Server) { + args[0] = X11Server; + } else { + Error(_("x-setup: No X server configured!\n")); + return; + } + + argn = 1; + if (X11DisplayName) { // append display name + args[argn++] = X11DisplayName; + } + // split X server arguments string into words + if ((sval = X11ServerArguments)) { + char *s; + + s = buf = strdupa(sval); + while ((sval = strsep(&s, " \t"))) { + args[argn++] = sval; + + if (argn == XSERVER_MAX_ARGS - 1) { // argument overflow + Error(_("x-setup: too many arguments for xserver\n")); + // argn = 1; + break; + } + } + } + // FIXME: auth + // FIXME: append VTxx + args[argn] = NULL; + + // arm the signal + memset(&usr1, 0, sizeof(struct sigaction)); + usr1.sa_handler = Usr1Handler; + sigaction(SIGUSR1, &usr1, NULL); + + Debug(3, "x-setup: Starting X server '%s' '%s'\n", args[0], + X11ServerArguments); + // fork + if ((pid = vfork())) { // parent + + X11ServerPid = pid; + Debug(3, "x-setup: Started x-server pid=%d\n", X11ServerPid); + + return; + } + // child + signal(SIGUSR1, SIG_IGN); // ignore to force answer + // start the X server + execvp(args[0], (char *const *)args); + + Error(_("x-setup: Failed to start X server '%s'\n"), args[0]); +} + +/** +** Prepare plugin. +*/ +void Start(void) +{ + if (StartX11Server) { + StartXServer(); + } + CodecInit(); + // FIXME: AudioInit for HDMI after X11 startup + AudioInit(); + if (!StartX11Server) { + StartVideo(); + } +} + +/** +** Stop plugin. +*/ +void Stop(void) +{ + Debug(3, "video: max used PES packet size: %d\n", VideoMaxPacketSize); + + // lets hope that vdr does a good thead cleanup + if (MyVideoDecoder) { + CodecVideoClose(MyVideoDecoder); + MyVideoDecoder = NULL; + } + if (MyAudioDecoder) { + CodecAudioClose(MyAudioDecoder); + MyAudioDecoder = NULL; + } + + VideoExit(); + AudioExit(); + CodecExit(); + + if (StartX11Server) { + Debug(3, "x-setup: Stop x11 server\n"); + + if (X11ServerPid) { + kill(X11ServerPid, SIGTERM); + } + } +} + +/** +** Main thread hook, periodic called from main thread. +*/ +void MainThreadHook(void) +{ + VideoDisplayHandler(); +} |