tls_gnutls: Readd support for nonblocking operation
[ffmpeg.git] / libavformat / img2enc.c
1 /*
2  * Image format
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  * Copyright (c) 2004 Michael Niedermayer
5  *
6  * This file is part of Libav.
7  *
8  * Libav is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * Libav is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with Libav; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22
23 #include "libavutil/intreadwrite.h"
24 #include "libavutil/avstring.h"
25 #include "libavutil/log.h"
26 #include "avformat.h"
27 #include "avio_internal.h"
28 #include "internal.h"
29 #include "libavutil/opt.h"
30
31 typedef struct RenameIO {
32     AVIOContext *pb;
33     char filename[1024];
34     char tmp[1024];
35 } RenameIO;
36
37 typedef struct VideoMuxData {
38     const AVClass *class;  /**< Class for private options. */
39     int img_number;
40     int is_pipe;
41     char path[1024];
42     int update;
43 } VideoMuxData;
44
45 static int write_header(AVFormatContext *s)
46 {
47     VideoMuxData *img = s->priv_data;
48
49     av_strlcpy(img->path, s->filename, sizeof(img->path));
50
51     /* find format */
52     if (s->oformat->flags & AVFMT_NOFILE)
53         img->is_pipe = 0;
54     else
55         img->is_pipe = 1;
56
57     return 0;
58 }
59
60 static int open_temporary(AVFormatContext *s, RenameIO *out, const char *filename)
61 {
62     snprintf(out->tmp, sizeof(out->tmp), "%s.tmp", filename);
63     av_strlcpy(out->filename, filename, sizeof(out->filename));
64     if (s->io_open(s, &out->pb, out->tmp, AVIO_FLAG_WRITE, NULL) < 0) {
65         av_log(s, AV_LOG_ERROR, "Could not open file : %s\n", out->tmp);
66         return AVERROR(EIO);
67     }
68
69     return 0;
70 }
71
72 static void close_and_rename(AVFormatContext *s, RenameIO *out)
73 {
74     ff_format_io_close(s, &out->pb);
75     ff_rename(out->tmp, out->filename);
76 }
77
78 static int write_packet(AVFormatContext *s, AVPacket *pkt)
79 {
80     VideoMuxData *img = s->priv_data;
81     RenameIO out[3];
82     char filename[1024];
83     AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;
84     int i;
85
86     if (!img->is_pipe) {
87         if (img->update) {
88             av_strlcpy(filename, img->path, sizeof(filename));
89         } else if (av_get_frame_filename(filename, sizeof(filename), img->path, img->img_number) < 0 &&
90                    img->img_number > 1) {
91             av_log(s, AV_LOG_ERROR,
92                    "Could not get frame filename number %d from pattern '%s'\n",
93                    img->img_number, img->path);
94             return AVERROR(EIO);
95         }
96         for (i = 0; i < 3; i++) {
97             int ret = open_temporary(s, &out[i], filename);
98             if (ret < 0)
99                 return ret;
100             if (par->codec_id != AV_CODEC_ID_RAWVIDEO)
101                 break;
102             filename[strlen(filename) - 1] = 'U' + i;
103         }
104     } else {
105         out[0].pb = s->pb;
106     }
107
108     if (par->codec_id == AV_CODEC_ID_RAWVIDEO) {
109         int ysize = par->width * par->height;
110         avio_write(out[0].pb, pkt->data, ysize);
111         avio_write(out[1].pb, pkt->data + ysize,                           (pkt->size - ysize) / 2);
112         avio_write(out[2].pb, pkt->data + ysize + (pkt->size - ysize) / 2, (pkt->size - ysize) / 2);
113         close_and_rename(s, &out[1]);
114         close_and_rename(s, &out[2]);
115     } else {
116         if (ff_guess_image2_codec(s->filename) == AV_CODEC_ID_JPEG2000) {
117             AVStream *st = s->streams[0];
118             if (st->codecpar->extradata_size > 8 &&
119                 AV_RL32(st->codecpar->extradata + 4) == MKTAG('j', 'p', '2', 'h')) {
120                 if (pkt->size < 8 ||
121                     AV_RL32(pkt->data + 4) != MKTAG('j', 'p', '2', 'c'))
122                     goto error;
123                 avio_wb32(out[0].pb, 12);
124                 ffio_wfourcc(out[0].pb, "jP  ");
125                 avio_wb32(out[0].pb, 0x0D0A870A); // signature
126                 avio_wb32(out[0].pb, 20);
127                 ffio_wfourcc(out[0].pb, "ftyp");
128                 ffio_wfourcc(out[0].pb, "jp2 ");
129                 avio_wb32(out[0].pb, 0);
130                 ffio_wfourcc(out[0].pb, "jp2 ");
131                 avio_write(out[0].pb, st->codecpar->extradata, st->codecpar->extradata_size);
132             } else if (pkt->size < 8 ||
133                        (!st->codecpar->extradata_size &&
134                         AV_RL32(pkt->data + 4) != MKTAG('j', 'P', ' ', ' '))) { // signature
135 error:
136                 av_log(s, AV_LOG_ERROR, "malformed JPEG 2000 codestream\n");
137                 return -1;
138             }
139         }
140         avio_write(out[0].pb, pkt->data, pkt->size);
141     }
142     avio_flush(out[0].pb);
143     if (!img->is_pipe) {
144         close_and_rename(s, &out[0]);
145     }
146
147     img->img_number++;
148     return 0;
149 }
150
151 #define OFFSET(x) offsetof(VideoMuxData, x)
152 #define ENC AV_OPT_FLAG_ENCODING_PARAM
153 static const AVOption muxoptions[] = {
154     { "start_number", "first number in the sequence", OFFSET(img_number), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, INT_MAX, ENC },
155     { "update",       "continuously overwrite one file", OFFSET(update),  AV_OPT_TYPE_INT, { .i64 = 0 }, 0,       1, ENC },
156     { NULL },
157 };
158
159 #if CONFIG_IMAGE2_MUXER
160 static const AVClass img2mux_class = {
161     .class_name = "image2 muxer",
162     .item_name  = av_default_item_name,
163     .option     = muxoptions,
164     .version    = LIBAVUTIL_VERSION_INT,
165 };
166
167 AVOutputFormat ff_image2_muxer = {
168     .name           = "image2",
169     .long_name      = NULL_IF_CONFIG_SMALL("image2 sequence"),
170     .extensions     = "bmp,dpx,jpeg,jpg,ljpg,pam,pbm,pcx,pgm,pgmyuv,png,"
171                       "ppm,sgi,tga,tif,tiff,jp2,xwd,sun,ras,rs,im1,im8,im24,"
172                       "sunras,webp,xbm,j2c,pix",
173     .priv_data_size = sizeof(VideoMuxData),
174     .video_codec    = AV_CODEC_ID_MJPEG,
175     .write_header   = write_header,
176     .write_packet   = write_packet,
177     .flags          = AVFMT_NOTIMESTAMPS | AVFMT_NODIMENSIONS | AVFMT_NOFILE,
178     .priv_class     = &img2mux_class,
179 };
180 #endif
181 #if CONFIG_IMAGE2PIPE_MUXER
182 AVOutputFormat ff_image2pipe_muxer = {
183     .name           = "image2pipe",
184     .long_name      = NULL_IF_CONFIG_SMALL("piped image2 sequence"),
185     .priv_data_size = sizeof(VideoMuxData),
186     .video_codec    = AV_CODEC_ID_MJPEG,
187     .write_header   = write_header,
188     .write_packet   = write_packet,
189     .flags          = AVFMT_NOTIMESTAMPS | AVFMT_NODIMENSIONS
190 };
191 #endif