Merge commit 'c0de9159a7ba5707aa0a5c2bc73ae78b7b87ec46'
authorMichael Niedermayer <michaelni@gmx.at>
Fri, 18 Jul 2014 19:48:31 +0000 (21:48 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Fri, 18 Jul 2014 19:48:37 +0000 (21:48 +0200)
* commit 'c0de9159a7ba5707aa0a5c2bc73ae78b7b87ec46':
  avdevice: Give names to anonymously typedeffed structs

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavdevice/bktr.c
libavdevice/fbdev_dec.c
libavdevice/jack_audio.c
libavdevice/oss_audio.c

diff --combined libavdevice/bktr.c
@@@ -7,23 -7,24 +7,23 @@@
   * and
   *           simple_grab.c Copyright (c) 1999 Roger Hardiman
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg 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
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
 -#include "libavformat/avformat.h"
  #include "libavformat/internal.h"
  #include "libavutil/internal.h"
  #include "libavutil/log.h"
  #include <sys/time.h>
  #include <signal.h>
  #include <stdint.h>
 +#include "avdevice.h"
  
- typedef struct {
+ typedef struct VideoData {
      AVClass *class;
      int video_fd;
      int tuner_fd;
      int width, height;
      uint64_t per_frame;
      int standard;
 -    char *video_size; /**< String describing video size, set by a private option. */
      char *framerate;  /**< Set by a private option. */
  } VideoData;
  
@@@ -103,7 -104,7 +103,7 @@@ static av_cold int bktr_init(const cha
      long ioctl_frequency;
      char *arg;
      int c;
 -    struct sigaction act = { 0 }, old;
 +    struct sigaction act = { {0} }, old;
  
      if (idev < 0 || idev > 4)
      {
@@@ -247,9 -248,15 +247,9 @@@ static int grab_read_header(AVFormatCon
  {
      VideoData *s = s1->priv_data;
      AVStream *st;
 -    int width, height;
      AVRational framerate;
      int ret = 0;
  
 -    if ((ret = av_parse_video_size(&width, &height, s->video_size)) < 0) {
 -        av_log(s1, AV_LOG_ERROR, "Could not parse video size '%s'.\n", s->video_size);
 -        goto out;
 -    }
 -
      if (!s->framerate)
          switch (s->standard) {
          case PAL:   s->framerate = av_strdup("pal");  break;
      }
      avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in use */
  
 -    s->width = width;
 -    s->height = height;
      s->per_frame = ((uint64_t)1000000 * framerate.den) / framerate.num;
  
      st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
      st->codec->pix_fmt = AV_PIX_FMT_YUV420P;
      st->codec->codec_id = AV_CODEC_ID_RAWVIDEO;
 -    st->codec->width = width;
 -    st->codec->height = height;
 +    st->codec->width = s->width;
 +    st->codec->height = s->height;
      st->codec->time_base.den = framerate.num;
      st->codec->time_base.num = framerate.den;
  
  
 -    if (bktr_init(s1->filename, width, height, s->standard,
 +    if (bktr_init(s1->filename, s->width, s->height, s->standard,
                    &s->video_fd, &s->tuner_fd, -1, 0.0) < 0) {
          ret = AVERROR(EIO);
          goto out;
@@@ -324,7 -333,7 +324,7 @@@ static const AVOption options[] = 
      { "PALN",     "", 0, AV_OPT_TYPE_CONST, {.i64 = PALN},  0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
      { "PALM",     "", 0, AV_OPT_TYPE_CONST, {.i64 = PALM},  0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
      { "NTSCJ",    "", 0, AV_OPT_TYPE_CONST, {.i64 = NTSCJ}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
 -    { "video_size", "A string describing frame size, such as 640x480 or hd720.", OFFSET(video_size), AV_OPT_TYPE_STRING, {.str = "vga"}, 0, 0, DEC },
 +    { "video_size", "A string describing frame size, such as 640x480 or hd720.", OFFSET(width), AV_OPT_TYPE_IMAGE_SIZE, {.str = "vga"}, 0, 0, DEC },
      { "framerate", "", OFFSET(framerate), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
      { NULL },
  };
@@@ -334,7 -343,6 +334,7 @@@ static const AVClass bktr_class = 
      .item_name  = av_default_item_name,
      .option     = options,
      .version    = LIBAVUTIL_VERSION_INT,
 +    .category   = AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,
  };
  
  AVInputFormat ff_bktr_demuxer = {
diff --combined libavdevice/fbdev_dec.c
@@@ -3,20 -3,20 +3,20 @@@
   * Copyright (c) 2009 Giliard B. de Freitas <giliarde@gmail.com>
   * Copyright (C) 2002 Gunnar Monell <gmo@linux.nu>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg 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
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
  #include "libavutil/time.h"
  #include "libavutil/parseutils.h"
  #include "libavutil/pixdesc.h"
 -#include "libavformat/avformat.h"
  #include "libavformat/internal.h"
 -
 -struct rgb_pixfmt_map_entry {
 -    int bits_per_pixel;
 -    int red_offset, green_offset, blue_offset, alpha_offset;
 -    enum AVPixelFormat pixfmt;
 -};
 -
 -static struct rgb_pixfmt_map_entry rgb_pixfmt_map[] = {
 -    // bpp, red_offset,  green_offset, blue_offset, alpha_offset, pixfmt
 -    {  32,       0,           8,          16,           24,   AV_PIX_FMT_RGBA  },
 -    {  32,      16,           8,           0,           24,   AV_PIX_FMT_BGRA  },
 -    {  32,       8,          16,          24,            0,   AV_PIX_FMT_ARGB  },
 -    {  32,       3,           2,           8,            0,   AV_PIX_FMT_ABGR  },
 -    {  24,       0,           8,          16,            0,   AV_PIX_FMT_RGB24 },
 -    {  24,      16,           8,           0,            0,   AV_PIX_FMT_BGR24 },
 -};
 -
 -static enum AVPixelFormat get_pixfmt_from_fb_varinfo(struct fb_var_screeninfo *varinfo)
 -{
 -    int i;
 -
 -    for (i = 0; i < FF_ARRAY_ELEMS(rgb_pixfmt_map); i++) {
 -        struct rgb_pixfmt_map_entry *entry = &rgb_pixfmt_map[i];
 -        if (entry->bits_per_pixel == varinfo->bits_per_pixel &&
 -            entry->red_offset     == varinfo->red.offset     &&
 -            entry->green_offset   == varinfo->green.offset   &&
 -            entry->blue_offset    == varinfo->blue.offset)
 -            return entry->pixfmt;
 -    }
 -
 -    return AV_PIX_FMT_NONE;
 -}
 +#include "avdevice.h"
 +#include "fbdev_common.h"
  
- typedef struct {
+ typedef struct FBDevContext {
      AVClass *class;          ///< class for private options
      int frame_size;          ///< size in bytes of a grabbed frame
      AVRational framerate_q;  ///< framerate
 -    char *framerate;         ///< framerate string set by a private option
      int64_t time_frame;      ///< time for the next frame to output (in 1/1000000 units)
  
      int fd;                  ///< framebuffer device file descriptor
@@@ -69,6 -101,12 +69,6 @@@ static av_cold int fbdev_read_header(AV
      enum AVPixelFormat pix_fmt;
      int ret, flags = O_RDONLY;
  
 -    ret = av_parse_video_rate(&fbdev->framerate_q, fbdev->framerate);
 -    if (ret < 0) {
 -        av_log(avctx, AV_LOG_ERROR, "Could not parse framerate '%s'.\n", fbdev->framerate);
 -        return ret;
 -    }
 -
      if (!(st = avformat_new_stream(avctx, NULL)))
          return AVERROR(ENOMEM);
      avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in microseconds */
          ret = AVERROR(errno);
          av_log(avctx, AV_LOG_ERROR,
                 "Could not open framebuffer device '%s': %s\n",
 -               avctx->filename, strerror(ret));
 +               avctx->filename, av_err2str(ret));
          return ret;
      }
  
      if (ioctl(fbdev->fd, FBIOGET_VSCREENINFO, &fbdev->varinfo) < 0) {
          ret = AVERROR(errno);
          av_log(avctx, AV_LOG_ERROR,
 -               "FBIOGET_VSCREENINFO: %s\n", strerror(errno));
 +               "FBIOGET_VSCREENINFO: %s\n", av_err2str(ret));
          goto fail;
      }
  
      if (ioctl(fbdev->fd, FBIOGET_FSCREENINFO, &fbdev->fixinfo) < 0) {
          ret = AVERROR(errno);
          av_log(avctx, AV_LOG_ERROR,
 -               "FBIOGET_FSCREENINFO: %s\n", strerror(errno));
 +               "FBIOGET_FSCREENINFO: %s\n", av_err2str(ret));
          goto fail;
      }
  
 -    pix_fmt = get_pixfmt_from_fb_varinfo(&fbdev->varinfo);
 +    pix_fmt = ff_get_pixfmt_from_fb_varinfo(&fbdev->varinfo);
      if (pix_fmt == AV_PIX_FMT_NONE) {
          ret = AVERROR(EINVAL);
          av_log(avctx, AV_LOG_ERROR,
      fbdev->data = mmap(NULL, fbdev->fixinfo.smem_len, PROT_READ, MAP_SHARED, fbdev->fd, 0);
      if (fbdev->data == MAP_FAILED) {
          ret = AVERROR(errno);
 -        av_log(avctx, AV_LOG_ERROR, "Error in mmap(): %s\n", strerror(errno));
 +        av_log(avctx, AV_LOG_ERROR, "Error in mmap(): %s\n", av_err2str(ret));
          goto fail;
      }
  
      st->codec->width      = fbdev->width;
      st->codec->height     = fbdev->height;
      st->codec->pix_fmt    = pix_fmt;
 -    st->codec->time_base  = (AVRational){fbdev->framerate_q.den, fbdev->framerate_q.num};
 +    st->codec->time_base  = av_inv_q(fbdev->framerate_q);
      st->codec->bit_rate   =
          fbdev->width * fbdev->height * fbdev->bytes_per_pixel * av_q2d(fbdev->framerate_q) * 8;
  
@@@ -154,22 -192,20 +154,22 @@@ static int fbdev_read_packet(AVFormatCo
          fbdev->time_frame = av_gettime();
  
      /* wait based on the frame rate */
 -    curtime = av_gettime();
 -    delay = fbdev->time_frame - curtime;
 -    av_dlog(avctx,
 -            "time_frame:%"PRId64" curtime:%"PRId64" delay:%"PRId64"\n",
 -            fbdev->time_frame, curtime, delay);
 -    if (delay > 0) {
 +    while (1) {
 +        curtime = av_gettime();
 +        delay = fbdev->time_frame - curtime;
 +        av_dlog(avctx,
 +                "time_frame:%"PRId64" curtime:%"PRId64" delay:%"PRId64"\n",
 +                fbdev->time_frame, curtime, delay);
 +        if (delay <= 0) {
 +            fbdev->time_frame += INT64_C(1000000) / av_q2d(fbdev->framerate_q);
 +            break;
 +        }
          if (avctx->flags & AVFMT_FLAG_NONBLOCK)
              return AVERROR(EAGAIN);
          ts.tv_sec  =  delay / 1000000;
          ts.tv_nsec = (delay % 1000000) * 1000;
          while (nanosleep(&ts, &ts) < 0 && errno == EINTR);
      }
 -    /* compute the time of the next frame */
 -    fbdev->time_frame += INT64_C(1000000) / av_q2d(fbdev->framerate_q);
  
      if ((ret = av_new_packet(pkt, fbdev->frame_size)) < 0)
          return ret;
      /* refresh fbdev->varinfo, visible data position may change at each call */
      if (ioctl(fbdev->fd, FBIOGET_VSCREENINFO, &fbdev->varinfo) < 0)
          av_log(avctx, AV_LOG_WARNING,
 -               "Error refreshing variable info: %s\n", strerror(errno));
 +               "Error refreshing variable info: %s\n", av_err2str(ret));
  
      pkt->pts = curtime;
  
                          fbdev->varinfo.yoffset * fbdev->fixinfo.line_length;
      pout = pkt->data;
  
 -    // TODO it'd be nice if the lines were aligned
      for (i = 0; i < fbdev->height; i++) {
          memcpy(pout, pin, fbdev->frame_linesize);
          pin  += fbdev->fixinfo.line_length;
@@@ -199,21 -236,16 +199,21 @@@ static av_cold int fbdev_read_close(AVF
  {
      FBDevContext *fbdev = avctx->priv_data;
  
 -    munmap(fbdev->data, fbdev->frame_size);
 +    munmap(fbdev->data, fbdev->fixinfo.smem_len);
      close(fbdev->fd);
  
      return 0;
  }
  
 +static int fbdev_get_device_list(AVFormatContext *s, AVDeviceInfoList *device_list)
 +{
 +    return ff_fbdev_get_device_list(device_list);
 +}
 +
  #define OFFSET(x) offsetof(FBDevContext, x)
  #define DEC AV_OPT_FLAG_DECODING_PARAM
  static const AVOption options[] = {
 -    { "framerate","", OFFSET(framerate), AV_OPT_TYPE_STRING, {.str = "25"}, 0, 0, DEC },
 +    { "framerate","", OFFSET(framerate_q), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, 0, DEC },
      { NULL },
  };
  
@@@ -222,7 -254,6 +222,7 @@@ static const AVClass fbdev_class = 
      .item_name  = av_default_item_name,
      .option     = options,
      .version    = LIBAVUTIL_VERSION_INT,
 +    .category   = AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,
  };
  
  AVInputFormat ff_fbdev_demuxer = {
      .read_header    = fbdev_read_header,
      .read_packet    = fbdev_read_packet,
      .read_close     = fbdev_read_close,
 +    .get_device_list = fbdev_get_device_list,
      .flags          = AVFMT_NOFILE,
      .priv_class     = &fbdev_class,
  };
diff --combined libavdevice/jack_audio.c
@@@ -3,20 -3,20 +3,20 @@@
   * Copyright (c) 2009 Samalyse
   * Author: Olivier Guilyardi <olivier samalyse com>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg 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
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
  #include "libavformat/avformat.h"
  #include "libavformat/internal.h"
  #include "timefilter.h"
 +#include "avdevice.h"
  
  /**
   * Size of the internal FIFO buffers as a number of audio packets
   */
  #define FIFO_PACKETS_NUM 16
  
- typedef struct {
+ typedef struct JackData {
      AVClass        *class;
      jack_client_t * client;
      int             activated;
@@@ -152,6 -151,7 +152,6 @@@ static int start_jack(AVFormatContext *
      JackData *self = context->priv_data;
      jack_status_t status;
      int i, test;
 -    double o, period;
  
      /* Register as a JACK client, using the context filename as client name. */
      self->client = jack_client_open(context->filename, JackNullOption, &status);
      sem_init(&self->packet_count, 0, 0);
  
      self->sample_rate = jack_get_sample_rate(self->client);
 -    self->ports       = av_malloc(self->nports * sizeof(*self->ports));
 +    self->ports       = av_malloc_array(self->nports, sizeof(*self->ports));
      self->buffer_size = jack_get_buffer_size(self->client);
  
      /* Register JACK ports */
      jack_set_xrun_callback(self->client, xrun_callback, self);
  
      /* Create time filter */
 -    period            = (double) self->buffer_size / self->sample_rate;
 -    o                 = 2 * M_PI * 1.5 * period; /// bandwidth: 1.5Hz
 -    self->timefilter  = ff_timefilter_new (1.0 / self->sample_rate, sqrt(2 * o), o * o);
 +    self->timefilter  = ff_timefilter_new (1.0 / self->sample_rate, self->buffer_size, 1.5);
      if (!self->timefilter) {
          jack_client_close(self->client);
          return AVERROR(ENOMEM);
      }
  
      /* Create FIFO buffers */
 -    self->filled_pkts = av_fifo_alloc(FIFO_PACKETS_NUM * sizeof(AVPacket));
 +    self->filled_pkts = av_fifo_alloc_array(FIFO_PACKETS_NUM, sizeof(AVPacket));
      /* New packets FIFO with one extra packet for safety against underruns */
 -    self->new_pkts    = av_fifo_alloc((FIFO_PACKETS_NUM + 1) * sizeof(AVPacket));
 +    self->new_pkts    = av_fifo_alloc_array((FIFO_PACKETS_NUM + 1), sizeof(AVPacket));
      if ((test = supply_new_packets(self, context))) {
          jack_client_close(self->client);
          return test;
  
  }
  
 -static void free_pkt_fifo(AVFifoBuffer *fifo)
 +static void free_pkt_fifo(AVFifoBuffer **fifo)
  {
      AVPacket pkt;
 -    while (av_fifo_size(fifo)) {
 -        av_fifo_generic_read(fifo, &pkt, sizeof(pkt), NULL);
 +    while (av_fifo_size(*fifo)) {
 +        av_fifo_generic_read(*fifo, &pkt, sizeof(pkt), NULL);
          av_free_packet(&pkt);
      }
 -    av_fifo_free(fifo);
 +    av_fifo_freep(fifo);
  }
  
  static void stop_jack(JackData *self)
          jack_client_close(self->client);
      }
      sem_destroy(&self->packet_count);
 -    free_pkt_fifo(self->new_pkts);
 -    free_pkt_fifo(self->filled_pkts);
 +    free_pkt_fifo(&self->new_pkts);
 +    free_pkt_fifo(&self->filled_pkts);
      av_freep(&self->ports);
      ff_timefilter_destroy(self->timefilter);
  }
@@@ -333,7 -335,6 +333,7 @@@ static const AVClass jack_indev_class 
      .item_name      = av_default_item_name,
      .option         = options,
      .version        = LIBAVUTIL_VERSION_INT,
 +    .category       = AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT,
  };
  
  AVInputFormat ff_jack_demuxer = {
diff --combined libavdevice/oss_audio.c
@@@ -2,20 -2,20 +2,20 @@@
   * Linux audio play and grab interface
   * Copyright (c) 2000, 2001 Fabrice Bellard
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg 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
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -30,9 -30,7 +30,9 @@@
  #else
  #include <sys/soundcard.h>
  #endif
 +#if HAVE_UNISTD_H
  #include <unistd.h>
 +#endif
  #include <fcntl.h>
  #include <sys/ioctl.h>
  
  #include "libavutil/opt.h"
  #include "libavutil/time.h"
  #include "libavcodec/avcodec.h"
 -#include "libavformat/avformat.h"
 +#include "avdevice.h"
  #include "libavformat/internal.h"
  
  #define AUDIO_BLOCK_SIZE 4096
  
- typedef struct {
+ typedef struct AudioData {
      AVClass *class;
      int fd;
      int sample_rate;
@@@ -79,11 -77,8 +79,11 @@@ static int audio_open(AVFormatContext *
      }
  
      /* non blocking mode */
 -    if (!is_output)
 -        fcntl(audio_fd, F_SETFL, O_NONBLOCK);
 +    if (!is_output) {
 +        if (fcntl(audio_fd, F_SETFL, O_NONBLOCK) < 0) {
 +            av_log(s1, AV_LOG_WARNING, "%s: Could not enable non block mode (%s)\n", audio_device, strerror(errno));
 +        }
 +    }
  
      s->frame_size = AUDIO_BLOCK_SIZE;
  
@@@ -298,7 -293,6 +298,7 @@@ static const AVClass oss_demuxer_class 
      .item_name      = av_default_item_name,
      .option         = options,
      .version        = LIBAVUTIL_VERSION_INT,
 +    .category       = AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT,
  };
  
  AVInputFormat ff_oss_demuxer = {
  #endif
  
  #if CONFIG_OSS_OUTDEV
 +static const AVClass oss_muxer_class = {
 +    .class_name     = "OSS muxer",
 +    .item_name      = av_default_item_name,
 +    .version        = LIBAVUTIL_VERSION_INT,
 +    .category       = AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT,
 +};
 +
  AVOutputFormat ff_oss_muxer = {
      .name           = "oss",
      .long_name      = NULL_IF_CONFIG_SMALL("OSS (Open Sound System) playback"),
      .write_packet   = audio_write_packet,
      .write_trailer  = audio_write_trailer,
      .flags          = AVFMT_NOFILE,
 +    .priv_class     = &oss_muxer_class,
  };
  #endif