dnxhdenc: Optimize get_pixels_8x4_sym for 10-bit
[ffmpeg.git] / libavformat / nuv.c
1 /*
2  * NuppelVideo demuxer.
3  * Copyright (c) 2006 Reimar Doeffinger
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #include "libavutil/channel_layout.h"
23 #include "libavutil/imgutils.h"
24 #include "libavutil/intreadwrite.h"
25 #include "libavutil/intfloat.h"
26 #include "avformat.h"
27 #include "internal.h"
28 #include "riff.h"
29
30 static const AVCodecTag nuv_audio_tags[] = {
31     { AV_CODEC_ID_PCM_S16LE, MKTAG('R', 'A', 'W', 'A') },
32     { AV_CODEC_ID_MP3,       MKTAG('L', 'A', 'M', 'E') },
33     { AV_CODEC_ID_NONE,      0 },
34 };
35
36 typedef struct NUVContext {
37     int v_id;
38     int a_id;
39     int rtjpg_video;
40 } NUVContext;
41
42 typedef enum {
43     NUV_VIDEO     = 'V',
44     NUV_EXTRADATA = 'D',
45     NUV_AUDIO     = 'A',
46     NUV_SEEKP     = 'R',
47     NUV_MYTHEXT   = 'X'
48 } nuv_frametype;
49
50 static int nuv_probe(AVProbeData *p)
51 {
52     if (!memcmp(p->buf, "NuppelVideo", 12))
53         return AVPROBE_SCORE_MAX;
54     if (!memcmp(p->buf, "MythTVVideo", 12))
55         return AVPROBE_SCORE_MAX;
56     return 0;
57 }
58
59 /// little macro to sanitize packet size
60 #define PKTSIZE(s) (s &  0xffffff)
61
62 /**
63  * @brief read until we found all data needed for decoding
64  * @param vst video stream of which to change parameters
65  * @param ast video stream of which to change parameters
66  * @param myth set if this is a MythTVVideo format file
67  * @return 0 or AVERROR code
68  */
69 static int get_codec_data(AVIOContext *pb, AVStream *vst,
70                           AVStream *ast, int myth)
71 {
72     nuv_frametype frametype;
73
74     if (!vst && !myth)
75         return 1; // no codec data needed
76     while (!avio_feof(pb)) {
77         int size, subtype;
78
79         frametype = avio_r8(pb);
80         switch (frametype) {
81         case NUV_EXTRADATA:
82             subtype = avio_r8(pb);
83             avio_skip(pb, 6);
84             size = PKTSIZE(avio_rl32(pb));
85             if (vst && subtype == 'R') {
86                 if (vst->codec->extradata) {
87                     av_freep(&vst->codec->extradata);
88                     vst->codec->extradata_size = 0;
89                 }
90                 if (ff_get_extradata(vst->codec, pb, size) < 0)
91                     return AVERROR(ENOMEM);
92                 size = 0;
93                 if (!myth)
94                     return 0;
95             }
96             break;
97         case NUV_MYTHEXT:
98             avio_skip(pb, 7);
99             size = PKTSIZE(avio_rl32(pb));
100             if (size != 128 * 4)
101                 break;
102             avio_rl32(pb); // version
103             if (vst) {
104                 vst->codec->codec_tag = avio_rl32(pb);
105                 vst->codec->codec_id =
106                     ff_codec_get_id(ff_codec_bmp_tags, vst->codec->codec_tag);
107                 if (vst->codec->codec_tag == MKTAG('R', 'J', 'P', 'G'))
108                     vst->codec->codec_id = AV_CODEC_ID_NUV;
109             } else
110                 avio_skip(pb, 4);
111
112             if (ast) {
113                 int id;
114
115                 ast->codec->codec_tag             = avio_rl32(pb);
116                 ast->codec->sample_rate           = avio_rl32(pb);
117                 ast->codec->bits_per_coded_sample = avio_rl32(pb);
118                 ast->codec->channels              = avio_rl32(pb);
119                 ast->codec->channel_layout        = 0;
120
121                 id = ff_wav_codec_get_id(ast->codec->codec_tag,
122                                          ast->codec->bits_per_coded_sample);
123                 if (id == AV_CODEC_ID_NONE) {
124                     id = ff_codec_get_id(nuv_audio_tags, ast->codec->codec_tag);
125                     if (id == AV_CODEC_ID_PCM_S16LE)
126                         id = ff_get_pcm_codec_id(ast->codec->bits_per_coded_sample,
127                                                  0, 0, ~1);
128                 }
129                 ast->codec->codec_id = id;
130
131                 ast->need_parsing = AVSTREAM_PARSE_FULL;
132             } else
133                 avio_skip(pb, 4 * 4);
134
135             size -= 6 * 4;
136             avio_skip(pb, size);
137             return 0;
138         case NUV_SEEKP:
139             size = 11;
140             break;
141         default:
142             avio_skip(pb, 7);
143             size = PKTSIZE(avio_rl32(pb));
144             break;
145         }
146         avio_skip(pb, size);
147     }
148
149     return 0;
150 }
151
152 static int nuv_header(AVFormatContext *s)
153 {
154     NUVContext *ctx = s->priv_data;
155     AVIOContext *pb = s->pb;
156     char id_string[12];
157     double aspect, fps;
158     int is_mythtv, width, height, v_packs, a_packs, ret;
159     AVStream *vst = NULL, *ast = NULL;
160
161     avio_read(pb, id_string, 12);
162     is_mythtv = !memcmp(id_string, "MythTVVideo", 12);
163     avio_skip(pb, 5);       // version string
164     avio_skip(pb, 3);       // padding
165     width  = avio_rl32(pb);
166     height = avio_rl32(pb);
167     avio_rl32(pb);          // unused, "desiredwidth"
168     avio_rl32(pb);          // unused, "desiredheight"
169     avio_r8(pb);            // 'P' == progressive, 'I' == interlaced
170     avio_skip(pb, 3);       // padding
171     aspect = av_int2double(avio_rl64(pb));
172     if (aspect > 0.9999 && aspect < 1.0001)
173         aspect = 4.0 / 3.0;
174     fps = av_int2double(avio_rl64(pb));
175
176     // number of packets per stream type, -1 means unknown, e.g. streaming
177     v_packs = avio_rl32(pb);
178     a_packs = avio_rl32(pb);
179     avio_rl32(pb); // text
180
181     avio_rl32(pb); // keyframe distance (?)
182
183     if (v_packs) {
184         vst = avformat_new_stream(s, NULL);
185         if (!vst)
186             return AVERROR(ENOMEM);
187         ctx->v_id = vst->index;
188
189         ret = av_image_check_size(width, height, 0, ctx);
190         if (ret < 0)
191             return ret;
192
193         vst->codec->codec_type            = AVMEDIA_TYPE_VIDEO;
194         vst->codec->codec_id              = AV_CODEC_ID_NUV;
195         vst->codec->width                 = width;
196         vst->codec->height                = height;
197         vst->codec->bits_per_coded_sample = 10;
198         vst->sample_aspect_ratio          = av_d2q(aspect * height / width,
199                                                    10000);
200 #if FF_API_R_FRAME_RATE
201         vst->r_frame_rate =
202 #endif
203         vst->avg_frame_rate = av_d2q(fps, 60000);
204         avpriv_set_pts_info(vst, 32, 1, 1000);
205     } else
206         ctx->v_id = -1;
207
208     if (a_packs) {
209         ast = avformat_new_stream(s, NULL);
210         if (!ast)
211             return AVERROR(ENOMEM);
212         ctx->a_id = ast->index;
213
214         ast->codec->codec_type            = AVMEDIA_TYPE_AUDIO;
215         ast->codec->codec_id              = AV_CODEC_ID_PCM_S16LE;
216         ast->codec->channels              = 2;
217         ast->codec->channel_layout        = AV_CH_LAYOUT_STEREO;
218         ast->codec->sample_rate           = 44100;
219         ast->codec->bit_rate              = 2 * 2 * 44100 * 8;
220         ast->codec->block_align           = 2 * 2;
221         ast->codec->bits_per_coded_sample = 16;
222         avpriv_set_pts_info(ast, 32, 1, 1000);
223     } else
224         ctx->a_id = -1;
225
226     if ((ret = get_codec_data(pb, vst, ast, is_mythtv)) < 0)
227         return ret;
228
229     ctx->rtjpg_video = vst && vst->codec->codec_id == AV_CODEC_ID_NUV;
230
231     return 0;
232 }
233
234 #define HDRSIZE 12
235
236 static int nuv_packet(AVFormatContext *s, AVPacket *pkt)
237 {
238     NUVContext *ctx = s->priv_data;
239     AVIOContext *pb = s->pb;
240     uint8_t hdr[HDRSIZE];
241     nuv_frametype frametype;
242     int ret, size;
243
244     while (!avio_feof(pb)) {
245         int copyhdrsize = ctx->rtjpg_video ? HDRSIZE : 0;
246         uint64_t pos    = avio_tell(pb);
247
248         ret = avio_read(pb, hdr, HDRSIZE);
249         if (ret < HDRSIZE)
250             return ret < 0 ? ret : AVERROR(EIO);
251
252         frametype = hdr[0];
253         size      = PKTSIZE(AV_RL32(&hdr[8]));
254
255         switch (frametype) {
256         case NUV_EXTRADATA:
257             if (!ctx->rtjpg_video) {
258                 avio_skip(pb, size);
259                 break;
260             }
261         case NUV_VIDEO:
262             if (ctx->v_id < 0) {
263                 av_log(s, AV_LOG_ERROR, "Video packet in file without video stream!\n");
264                 avio_skip(pb, size);
265                 break;
266             }
267             ret = av_new_packet(pkt, copyhdrsize + size);
268             if (ret < 0)
269                 return ret;
270
271             pkt->pos          = pos;
272             pkt->flags       |= hdr[2] == 0 ? AV_PKT_FLAG_KEY : 0;
273             pkt->pts          = AV_RL32(&hdr[4]);
274             pkt->stream_index = ctx->v_id;
275             memcpy(pkt->data, hdr, copyhdrsize);
276             ret = avio_read(pb, pkt->data + copyhdrsize, size);
277             if (ret < 0) {
278                 av_free_packet(pkt);
279                 return ret;
280             }
281             if (ret < size)
282                 av_shrink_packet(pkt, copyhdrsize + ret);
283             return 0;
284         case NUV_AUDIO:
285             if (ctx->a_id < 0) {
286                 av_log(s, AV_LOG_ERROR, "Audio packet in file without audio stream!\n");
287                 avio_skip(pb, size);
288                 break;
289             }
290             ret               = av_get_packet(pb, pkt, size);
291             pkt->flags       |= AV_PKT_FLAG_KEY;
292             pkt->pos          = pos;
293             pkt->pts          = AV_RL32(&hdr[4]);
294             pkt->stream_index = ctx->a_id;
295             if (ret < 0)
296                 return ret;
297             return 0;
298         case NUV_SEEKP:
299             // contains no data, size value is invalid
300             break;
301         default:
302             avio_skip(pb, size);
303             break;
304         }
305     }
306
307     return AVERROR(EIO);
308 }
309
310 /**
311  * \brief looks for the string RTjjjjjjjjjj in the stream too resync reading
312  * \return 1 if the syncword is found 0 otherwise.
313  */
314 static int nuv_resync(AVFormatContext *s, int64_t pos_limit) {
315     AVIOContext *pb = s->pb;
316     uint32_t tag = 0;
317     while(!avio_feof(pb) && avio_tell(pb) < pos_limit) {
318         tag = (tag << 8) | avio_r8(pb);
319         if (tag                  == MKBETAG('R','T','j','j') &&
320            (tag = avio_rb32(pb)) == MKBETAG('j','j','j','j') &&
321            (tag = avio_rb32(pb)) == MKBETAG('j','j','j','j'))
322             return 1;
323     }
324     return 0;
325 }
326
327 /**
328  * \brief attempts to read a timestamp from stream at the given stream position
329  * \return timestamp if successful and AV_NOPTS_VALUE if failure
330  */
331 static int64_t nuv_read_dts(AVFormatContext *s, int stream_index,
332                             int64_t *ppos, int64_t pos_limit)
333 {
334     NUVContext *ctx = s->priv_data;
335     AVIOContext *pb = s->pb;
336     uint8_t hdr[HDRSIZE];
337     nuv_frametype frametype;
338     int size, key, idx;
339     int64_t pos, dts;
340
341     if (avio_seek(pb, *ppos, SEEK_SET) < 0)
342         return AV_NOPTS_VALUE;
343
344     if (!nuv_resync(s, pos_limit))
345         return AV_NOPTS_VALUE;
346
347     while (!avio_feof(pb) && avio_tell(pb) < pos_limit) {
348         if (avio_read(pb, hdr, HDRSIZE) < HDRSIZE)
349             return AV_NOPTS_VALUE;
350         frametype = hdr[0];
351         size = PKTSIZE(AV_RL32(&hdr[8]));
352         switch (frametype) {
353             case NUV_SEEKP:
354                 break;
355             case NUV_AUDIO:
356             case NUV_VIDEO:
357                 if (frametype == NUV_VIDEO) {
358                     idx = ctx->v_id;
359                     key = hdr[2] == 0;
360                 } else {
361                     idx = ctx->a_id;
362                     key = 1;
363                 }
364                 if (stream_index == idx) {
365
366                     pos = avio_tell(s->pb) - HDRSIZE;
367                     dts = AV_RL32(&hdr[4]);
368
369                     // TODO - add general support in av_gen_search, so it adds positions after reading timestamps
370                     av_add_index_entry(s->streams[stream_index], pos, dts, size + HDRSIZE, 0,
371                             key ? AVINDEX_KEYFRAME : 0);
372
373                     *ppos = pos;
374                     return dts;
375                 }
376             default:
377                 avio_skip(pb, size);
378                 break;
379         }
380     }
381     return AV_NOPTS_VALUE;
382 }
383
384
385 AVInputFormat ff_nuv_demuxer = {
386     .name           = "nuv",
387     .long_name      = NULL_IF_CONFIG_SMALL("NuppelVideo"),
388     .priv_data_size = sizeof(NUVContext),
389     .read_probe     = nuv_probe,
390     .read_header    = nuv_header,
391     .read_packet    = nuv_packet,
392     .read_timestamp = nuv_read_dts,
393     .flags          = AVFMT_GENERIC_INDEX,
394 };