Deprecate avctx.coded_frame

[ffmpeg] / libavdevice / v4l2.c

diff --git a/libavdevice/v4l2.c b/libavdevice/v4l2.c
index adb289d14085267bbbc6e961368ed019d233385f..a2b49c6002b54b35b641ababf35fb80e0176fc42 100644 (file)
--- a/libavdevice/v4l2.c
+++ b/libavdevice/v4l2.c
@@ -111,6 +111,9 @@ static struct fmt_map fmt_conversion_table[] = {
     { AV_PIX_FMT_NV12,    AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_NV12    },
     { AV_PIX_FMT_NONE,    AV_CODEC_ID_MJPEG,    V4L2_PIX_FMT_MJPEG   },
     { AV_PIX_FMT_NONE,    AV_CODEC_ID_MJPEG,    V4L2_PIX_FMT_JPEG    },
+#ifdef V4L2_PIX_FMT_H264
+    { AV_PIX_FMT_NONE,    AV_CODEC_ID_H264,     V4L2_PIX_FMT_H264    },
+#endif
 };
 
 static int device_open(AVFormatContext *ctx)
@@ -119,6 +122,7 @@ static int device_open(AVFormatContext *ctx)
     int fd;
     int res, err;
     int flags = O_RDWR;
+    char errbuf[128];
 
     if (ctx->flags & AVFMT_FLAG_NONBLOCK) {
         flags |= O_NONBLOCK;
@@ -126,19 +130,21 @@ static int device_open(AVFormatContext *ctx)
 
     fd = avpriv_open(ctx->filename, flags);
     if (fd < 0) {
-        err = errno;
+        err = AVERROR(errno);
+        av_strerror(err, errbuf, sizeof(errbuf));
 
         av_log(ctx, AV_LOG_ERROR, "Cannot open video device %s : %s\n",
-               ctx->filename, strerror(err));
+               ctx->filename, errbuf);
 
-        return AVERROR(err);
+        return err;
     }
 
     res = ioctl(fd, VIDIOC_QUERYCAP, &cap);
     if (res < 0) {
-        err = errno;
+        err = AVERROR(errno);
+        av_strerror(err, errbuf, sizeof(errbuf));
         av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QUERYCAP): %s\n",
-               strerror(err));
+               errbuf);
 
         goto fail;
     }
@@ -148,7 +154,7 @@ static int device_open(AVFormatContext *ctx)
 
     if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
         av_log(ctx, AV_LOG_ERROR, "Not a video capture device.\n");
-        err = ENODEV;
+        err = AVERROR(ENODEV);
 
         goto fail;
     }
@@ -156,7 +162,7 @@ static int device_open(AVFormatContext *ctx)
     if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
         av_log(ctx, AV_LOG_ERROR,
                "The device does not support the streaming I/O method.\n");
-        err = ENOSYS;
+        err = AVERROR(ENOSYS);
 
         goto fail;
     }
@@ -165,7 +171,7 @@ static int device_open(AVFormatContext *ctx)
 
 fail:
     close(fd);
-    return AVERROR(err);
+    return err;
 }
 
 static int device_init(AVFormatContext *ctx, int *width, int *height,
@@ -312,9 +318,9 @@ static void list_formats(AVFormatContext *ctx, int fd, int type)
                    vfd.description);
         } else if (vfd.flags & V4L2_FMT_FLAG_COMPRESSED &&
                    type & V4L_COMPFORMATS) {
-            AVCodec *codec = avcodec_find_encoder(codec_id);
+            const AVCodecDescriptor *desc = avcodec_descriptor_get(codec_id);
             av_log(ctx, AV_LOG_INFO, "C : %9s : %20s :",
-                   codec ? codec->name : "Unsupported",
+                   desc ? desc->name : "Unsupported",
                    vfd.description);
         } else {
             continue;
@@ -345,13 +351,14 @@ static int mmap_init(AVFormatContext *ctx)
 
     res = ioctl(s->fd, VIDIOC_REQBUFS, &req);
     if (res < 0) {
-        if (errno == EINVAL) {
+        res = AVERROR(errno);
+        if (res == AVERROR(EINVAL)) {
             av_log(ctx, AV_LOG_ERROR, "Device does not support mmap\n");
         } else {
             av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_REQBUFS)\n");
         }
 
-        return AVERROR(errno);
+        return res;
     }
 
     if (req.count < 2) {
@@ -361,13 +368,13 @@ static int mmap_init(AVFormatContext *ctx)
     }
     s->buffers = req.count;
     s->buf_start = av_malloc(sizeof(void *) * s->buffers);
-    if (s->buf_start == NULL) {
+    if (!s->buf_start) {
         av_log(ctx, AV_LOG_ERROR, "Cannot allocate buffer pointers\n");
 
         return AVERROR(ENOMEM);
     }
     s->buf_len = av_malloc(sizeof(unsigned int) * s->buffers);
-    if (s->buf_len == NULL) {
+    if (!s->buf_len) {
         av_log(ctx, AV_LOG_ERROR, "Cannot allocate buffer sizes\n");
         av_free(s->buf_start);
 
@@ -383,9 +390,10 @@ static int mmap_init(AVFormatContext *ctx)
 
         res = ioctl(s->fd, VIDIOC_QUERYBUF, &buf);
         if (res < 0) {
+            res = AVERROR(errno);
             av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QUERYBUF)\n");
 
-            return AVERROR(errno);
+            return res;
         }
 
         s->buf_len[i] = buf.length;
@@ -401,9 +409,12 @@ static int mmap_init(AVFormatContext *ctx)
                                s->fd, buf.m.offset);
 
         if (s->buf_start[i] == MAP_FAILED) {
-            av_log(ctx, AV_LOG_ERROR, "mmap: %s\n", strerror(errno));
+            char errbuf[128];
+            res = AVERROR(errno);
+            av_strerror(res, errbuf, sizeof(errbuf));
+            av_log(ctx, AV_LOG_ERROR, "mmap: %s\n", errbuf);
 
-            return AVERROR(errno);
+            return res;
         }
     }
 
@@ -423,6 +434,7 @@ static void mmap_release_buffer(void *opaque, uint8_t *data)
     int res, fd;
     struct buff_data *buf_descriptor = opaque;
     struct video_data *s = buf_descriptor->s;
+    char errbuf[128];
 
     buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     buf.memory = V4L2_MEMORY_MMAP;
@@ -431,9 +443,11 @@ static void mmap_release_buffer(void *opaque, uint8_t *data)
     av_free(buf_descriptor);
 
     res = ioctl(fd, VIDIOC_QBUF, &buf);
-    if (res < 0)
+    if (res < 0) {
+        av_strerror(AVERROR(errno), errbuf, sizeof(errbuf));
         av_log(NULL, AV_LOG_ERROR, "ioctl(VIDIOC_QBUF): %s\n",
-               strerror(errno));
+               errbuf);
+    }
     avpriv_atomic_int_add_and_fetch(&s->buffers_queued, 1);
 }
 
@@ -457,15 +471,18 @@ static int mmap_read_frame(AVFormatContext *ctx, AVPacket *pkt)
     /* FIXME: Some special treatment might be needed in case of loss of signal... */
     while ((res = ioctl(s->fd, VIDIOC_DQBUF, &buf)) < 0 && (errno == EINTR));
     if (res < 0) {
+        char errbuf[128];
         if (errno == EAGAIN) {
             pkt->size = 0;
 
             return AVERROR(EAGAIN);
         }
+        res = AVERROR(errno);
+        av_strerror(res, errbuf, sizeof(errbuf));
         av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_DQBUF): %s\n",
-               strerror(errno));
+               errbuf);
 
-        return AVERROR(errno);
+        return res;
     }
 
     if (buf.index >= s->buffers) {
@@ -496,9 +513,10 @@ static int mmap_read_frame(AVFormatContext *ctx, AVPacket *pkt)
 
         res = ioctl(s->fd, VIDIOC_QBUF, &buf);
         if (res < 0) {
+            res = AVERROR(errno);
             av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QBUF)\n");
             av_free_packet(pkt);
-            return AVERROR(errno);
+            return res;
         }
         avpriv_atomic_int_add_and_fetch(&s->buffers_queued, 1);
     } else {
@@ -513,7 +531,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
 #endif
 
         buf_descriptor = av_malloc(sizeof(struct buff_data));
-        if (buf_descriptor == NULL) {
+        if (!buf_descriptor) {
             /* Something went wrong... Since av_malloc() failed, we cannot even
              * allocate a buffer for memcpying into it
              */
@@ -542,7 +560,8 @@ static int mmap_start(AVFormatContext *ctx)
 {
     struct video_data *s = ctx->priv_data;
     enum v4l2_buf_type type;
-    int i, res;
+    int i, res, err;
+    char errbuf[128];
 
     for (i = 0; i < s->buffers; i++) {
         struct v4l2_buffer buf = {
@@ -553,10 +572,12 @@ static int mmap_start(AVFormatContext *ctx)
 
         res = ioctl(s->fd, VIDIOC_QBUF, &buf);
         if (res < 0) {
+            err = AVERROR(errno);
+            av_strerror(err, errbuf, sizeof(errbuf));
             av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QBUF): %s\n",
-                   strerror(errno));
+                   errbuf);
 
-            return AVERROR(errno);
+            return err;
         }
     }
     s->buffers_queued = s->buffers;
@@ -564,10 +585,12 @@ static int mmap_start(AVFormatContext *ctx)
     type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     res = ioctl(s->fd, VIDIOC_STREAMON, &type);
     if (res < 0) {
+        err = AVERROR(errno);
+        av_strerror(err, errbuf, sizeof(errbuf));
         av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_STREAMON): %s\n",
-               strerror(errno));
+               errbuf);
 
-        return AVERROR(errno);
+        return err;
     }
 
     return 0;
@@ -677,9 +700,12 @@ static int v4l2_set_parameters(AVFormatContext *s1)
         }
     } else {
         if (ioctl(s->fd, VIDIOC_G_PARM, &streamparm) != 0) {
+            char errbuf[128];
+            ret = AVERROR(errno);
+            av_strerror(ret, errbuf, sizeof(errbuf));
             av_log(s1, AV_LOG_ERROR, "ioctl(VIDIOC_G_PARM): %s\n",
-                   strerror(errno));
-            return AVERROR(errno);
+                   errbuf);
+            return ret;
         }
     }
     s1->streams[0]->avg_frame_rate.num = tpf->denominator;
@@ -759,8 +785,10 @@ static int v4l2_read_header(AVFormatContext *s1)
     if (s->pixel_format) {
         AVCodec *codec = avcodec_find_decoder_by_name(s->pixel_format);
 
-        if (codec)
+        if (codec) {
             s1->video_codec_id = codec->id;
+            st->need_parsing   = AVSTREAM_PARSE_HEADERS;
+        }
 
         pix_fmt = av_get_pix_fmt(s->pixel_format);
 
@@ -779,9 +807,12 @@ static int v4l2_read_header(AVFormatContext *s1)
                "Querying the device for the current frame size\n");
         fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
         if (ioctl(s->fd, VIDIOC_G_FMT, &fmt) < 0) {
+            char errbuf[128];
+            res = AVERROR(errno);
+            av_strerror(res, errbuf, sizeof(errbuf));
             av_log(s1, AV_LOG_ERROR, "ioctl(VIDIOC_G_FMT): %s\n",
-                   strerror(errno));
-            return AVERROR(errno);
+                   errbuf);
+            return res;
         }
 
         s->width  = fmt.fmt.pix.width;
@@ -835,7 +866,11 @@ static int v4l2_read_header(AVFormatContext *s1)
 static int v4l2_read_packet(AVFormatContext *s1, AVPacket *pkt)
 {
     struct video_data *s = s1->priv_data;
+#if FF_API_CODED_FRAME
+FF_DISABLE_DEPRECATION_WARNINGS
     AVFrame *frame = s1->streams[0]->codec->coded_frame;
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
     int res;
 
     av_init_packet(pkt);
@@ -843,10 +878,14 @@ static int v4l2_read_packet(AVFormatContext *s1, AVPacket *pkt)
         return res;
     }
 
+#if FF_API_CODED_FRAME
+FF_DISABLE_DEPRECATION_WARNINGS
     if (frame && s->interlaced) {
         frame->interlaced_frame = 1;
         frame->top_field_first = s->top_field_first;
     }
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
 
     return pkt->size;
 }