store index for seeking in the native timebase of each stream
[ffmpeg.git] / libavformat / raw.c
1 /* 
2  * RAW encoder and decoder
3  * Copyright (c) 2001 Fabrice Bellard.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  */
19 #include "avformat.h"
20
21 #ifdef CONFIG_ENCODERS
22 /* simple formats */
23 static int raw_write_header(struct AVFormatContext *s)
24 {
25     return 0;
26 }
27
28 static int raw_write_packet(struct AVFormatContext *s, int stream_index,
29                             const uint8_t *buf, int size, int64_t pts)
30 {
31     put_buffer(&s->pb, buf, size);
32     put_flush_packet(&s->pb);
33     return 0;
34 }
35
36 static int raw_write_trailer(struct AVFormatContext *s)
37 {
38     return 0;
39 }
40 #endif //CONFIG_ENCODERS
41
42 /* raw input */
43 static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap)
44 {
45     AVStream *st;
46     int id;
47
48     st = av_new_stream(s, 0);
49     if (!st)
50         return AVERROR_NOMEM;
51     if (ap) {
52         id = s->iformat->value;
53         if (id == CODEC_ID_RAWVIDEO) {
54             st->codec.codec_type = CODEC_TYPE_VIDEO;
55         } else {
56             st->codec.codec_type = CODEC_TYPE_AUDIO;
57         }
58         st->codec.codec_id = id;
59
60         switch(st->codec.codec_type) {
61         case CODEC_TYPE_AUDIO:
62             st->codec.sample_rate = ap->sample_rate;
63             st->codec.channels = ap->channels;
64             break;
65         case CODEC_TYPE_VIDEO:
66             st->codec.frame_rate      = ap->frame_rate;
67             st->codec.frame_rate_base = ap->frame_rate_base;
68             st->codec.width = ap->width;
69             st->codec.height = ap->height;
70             st->codec.pix_fmt = ap->pix_fmt;
71             break;
72         default:
73             return -1;
74         }
75     } else {
76         return -1;
77     }
78     return 0;
79 }
80
81 #define RAW_PACKET_SIZE 1024
82
83 static int raw_read_packet(AVFormatContext *s, AVPacket *pkt)
84 {
85     int ret, size;
86     //    AVStream *st = s->streams[0];
87     
88     size= RAW_PACKET_SIZE;
89
90     if (av_new_packet(pkt, size) < 0)
91         return -EIO;
92
93     pkt->stream_index = 0;
94     ret = get_buffer(&s->pb, pkt->data, size);
95     if (ret <= 0) {
96         av_free_packet(pkt);
97         return -EIO;
98     }
99     /* note: we need to modify the packet size here to handle the last
100        packet */
101     pkt->size = ret;
102     return ret;
103 }
104
105 static int raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt)
106 {
107     int ret, size;
108
109     size = RAW_PACKET_SIZE;
110
111     if (av_new_packet(pkt, size) < 0)
112         return -EIO;
113
114     pkt->stream_index = 0;
115     ret = get_partial_buffer(&s->pb, pkt->data, size);
116     if (ret <= 0) {
117         av_free_packet(pkt);
118         return -EIO;
119     }
120     pkt->size = ret;
121     return ret;
122 }
123
124 static int raw_read_close(AVFormatContext *s)
125 {
126     return 0;
127 }
128
129 int pcm_read_seek(AVFormatContext *s, 
130                   int stream_index, int64_t timestamp)
131 {
132     AVStream *st;
133     int block_align, byte_rate;
134     int64_t pos;
135
136     st = s->streams[0];
137     switch(st->codec.codec_id) {
138     case CODEC_ID_PCM_S16LE:
139     case CODEC_ID_PCM_S16BE:
140     case CODEC_ID_PCM_U16LE:
141     case CODEC_ID_PCM_U16BE:
142         block_align = 2 * st->codec.channels;
143         byte_rate = block_align * st->codec.sample_rate;
144         break;
145     case CODEC_ID_PCM_S8:
146     case CODEC_ID_PCM_U8:
147     case CODEC_ID_PCM_MULAW:
148     case CODEC_ID_PCM_ALAW:
149         block_align = st->codec.channels;
150         byte_rate = block_align * st->codec.sample_rate;
151         break;
152     default:
153         block_align = st->codec.block_align;
154         byte_rate = st->codec.bit_rate / 8;
155         break;
156     }
157     
158     if (block_align <= 0 || byte_rate <= 0)
159         return -1;
160
161     /* compute the position by aligning it to block_align */
162     pos = av_rescale(timestamp * byte_rate, st->time_base.num, st->time_base.den);
163     pos = (pos / block_align) * block_align;
164
165     /* recompute exact position */
166     st->cur_dts = (pos * AV_TIME_BASE) / byte_rate;
167     url_fseek(&s->pb, pos + s->data_offset, SEEK_SET);
168     return 0;
169 }
170
171 /* ac3 read */
172 static int ac3_read_header(AVFormatContext *s,
173                            AVFormatParameters *ap)
174 {
175     AVStream *st;
176
177     st = av_new_stream(s, 0);
178     if (!st)
179         return AVERROR_NOMEM;
180
181     st->codec.codec_type = CODEC_TYPE_AUDIO;
182     st->codec.codec_id = CODEC_ID_AC3;
183     st->need_parsing = 1;
184     /* the parameters will be extracted from the compressed bitstream */
185     return 0;
186 }
187
188 /* mpeg1/h263 input */
189 static int video_read_header(AVFormatContext *s,
190                              AVFormatParameters *ap)
191 {
192     AVStream *st;
193
194     st = av_new_stream(s, 0);
195     if (!st)
196         return AVERROR_NOMEM;
197
198     st->codec.codec_type = CODEC_TYPE_VIDEO;
199     st->codec.codec_id = s->iformat->value;
200     st->need_parsing = 1;
201
202     /* for mjpeg, specify frame rate */
203     /* for mpeg4 specify it too (most mpeg4 streams dont have the fixed_vop_rate set ...)*/
204     if (st->codec.codec_id == CODEC_ID_MJPEG || 
205         st->codec.codec_id == CODEC_ID_MPEG4) {
206         if (ap && ap->frame_rate) {
207             st->codec.frame_rate      = ap->frame_rate;
208             st->codec.frame_rate_base = ap->frame_rate_base;
209         } else {
210             st->codec.frame_rate      = 25;
211             st->codec.frame_rate_base = 1;
212         }
213     }
214     return 0;
215 }
216
217 #define SEQ_START_CODE          0x000001b3
218 #define GOP_START_CODE          0x000001b8
219 #define PICTURE_START_CODE      0x00000100
220
221 /* XXX: improve that by looking at several start codes */
222 static int mpegvideo_probe(AVProbeData *p)
223 {
224     int code;
225     const uint8_t *d;
226
227     /* we search the first start code. If it is a sequence, gop or
228        picture start code then we decide it is an mpeg video
229        stream. We do not send highest value to give a chance to mpegts */
230     /* NOTE: the search range was restricted to avoid too many false
231        detections */
232
233     if (p->buf_size < 6)
234         return 0;
235     d = p->buf;
236     code = (d[0] << 24) | (d[1] << 16) | (d[2] << 8) | (d[3]);
237     if ((code & 0xffffff00) == 0x100) {
238         if (code == SEQ_START_CODE ||
239             code == GOP_START_CODE ||
240             code == PICTURE_START_CODE)
241             return 50 - 1;
242         else
243             return 0;
244     }
245     return 0;
246 }
247
248 static int h263_probe(AVProbeData *p)
249 {
250     int code;
251     const uint8_t *d;
252
253     if (p->buf_size < 6)
254         return 0;
255     d = p->buf;
256     code = (d[0] << 14) | (d[1] << 6) | (d[2] >> 2);
257     if (code == 0x20) {
258         return 50;
259     }
260     return 0;
261 }
262
263 AVInputFormat ac3_iformat = {
264     "ac3",
265     "raw ac3",
266     0,
267     NULL,
268     ac3_read_header,
269     raw_read_partial_packet,
270     raw_read_close,
271     .extensions = "ac3",
272 };
273
274 #ifdef CONFIG_ENCODERS
275 AVOutputFormat ac3_oformat = {
276     "ac3",
277     "raw ac3",
278     "audio/x-ac3", 
279     "ac3",
280     0,
281     CODEC_ID_AC3,
282     0,
283     raw_write_header,
284     raw_write_packet,
285     raw_write_trailer,
286 };
287 #endif //CONFIG_ENCODERS
288
289 AVInputFormat h263_iformat = {
290     "h263",
291     "raw h263",
292     0,
293     h263_probe,
294     video_read_header,
295     raw_read_partial_packet,
296     raw_read_close,
297 //    .extensions = "h263", //FIXME remove after writing mpeg4_probe
298     .value = CODEC_ID_H263,
299 };
300
301 #ifdef CONFIG_ENCODERS
302 AVOutputFormat h263_oformat = {
303     "h263",
304     "raw h263",
305     "video/x-h263",
306     "h263",
307     0,
308     0,
309     CODEC_ID_H263,
310     raw_write_header,
311     raw_write_packet,
312     raw_write_trailer,
313 };
314 #endif //CONFIG_ENCODERS
315
316 AVInputFormat m4v_iformat = {
317     "m4v",
318     "raw MPEG4 video format",
319     0,
320     NULL /*mpegvideo_probe*/,
321     video_read_header,
322     raw_read_partial_packet,
323     raw_read_close,
324     .extensions = "m4v", //FIXME remove after writing mpeg4_probe
325     .value = CODEC_ID_MPEG4,
326 };
327
328 #ifdef CONFIG_ENCODERS
329 AVOutputFormat m4v_oformat = {
330     "m4v",
331     "raw MPEG4 video format",
332     NULL,
333     "m4v",
334     0,
335     CODEC_ID_NONE,
336     CODEC_ID_MPEG4,
337     raw_write_header,
338     raw_write_packet,
339     raw_write_trailer,
340 };
341 #endif //CONFIG_ENCODERS
342
343 AVInputFormat h264_iformat = {
344     "h264",
345     "raw H264 video format",
346     0,
347     NULL /*mpegvideo_probe*/,
348     video_read_header,
349     raw_read_partial_packet,
350     raw_read_close,
351     .extensions = "h26l,h264", //FIXME remove after writing mpeg4_probe
352     .value = CODEC_ID_H264,
353 };
354
355 #ifdef CONFIG_ENCODERS
356 AVOutputFormat h264_oformat = {
357     "h264",
358     "raw H264 video format",
359     NULL,
360     "h264",
361     0,
362     CODEC_ID_NONE,
363     CODEC_ID_H264,
364     raw_write_header,
365     raw_write_packet,
366     raw_write_trailer,
367 };
368 #endif //CONFIG_ENCODERS
369
370 AVInputFormat mpegvideo_iformat = {
371     "mpegvideo",
372     "MPEG video",
373     0,
374     mpegvideo_probe,
375     video_read_header,
376     raw_read_partial_packet,
377     raw_read_close,
378     .value = CODEC_ID_MPEG1VIDEO,
379 };
380
381 #ifdef CONFIG_ENCODERS
382 AVOutputFormat mpeg1video_oformat = {
383     "mpeg1video",
384     "MPEG video",
385     "video/x-mpeg",
386     "mpg,mpeg",
387     0,
388     0,
389     CODEC_ID_MPEG1VIDEO,
390     raw_write_header,
391     raw_write_packet,
392     raw_write_trailer,
393 };
394 #endif //CONFIG_ENCODERS
395
396 AVInputFormat mjpeg_iformat = {
397     "mjpeg",
398     "MJPEG video",
399     0,
400     NULL,
401     video_read_header,
402     raw_read_partial_packet,
403     raw_read_close,
404     .extensions = "mjpg,mjpeg",
405     .value = CODEC_ID_MJPEG,
406 };
407
408 #ifdef CONFIG_ENCODERS
409 AVOutputFormat mjpeg_oformat = {
410     "mjpeg",
411     "MJPEG video",
412     "video/x-mjpeg",
413     "mjpg,mjpeg",
414     0,
415     0,
416     CODEC_ID_MJPEG,
417     raw_write_header,
418     raw_write_packet,
419     raw_write_trailer,
420 };
421 #endif //CONFIG_ENCODERS
422
423 /* pcm formats */
424
425 #define PCMINPUTDEF(name, long_name, ext, codec) \
426 AVInputFormat pcm_ ## name ## _iformat = {\
427     #name,\
428     long_name,\
429     0,\
430     NULL,\
431     raw_read_header,\
432     raw_read_packet,\
433     raw_read_close,\
434     pcm_read_seek,\
435     .extensions = ext,\
436     .value = codec,\
437 };
438
439 #if !defined(CONFIG_ENCODERS) && defined(CONFIG_DECODERS)
440
441 #define PCMDEF(name, long_name, ext, codec) \
442     PCMINPUTDEF(name, long_name, ext, codec)
443
444 #else
445
446 #define PCMDEF(name, long_name, ext, codec) \
447     PCMINPUTDEF(name, long_name, ext, codec)\
448 \
449 AVOutputFormat pcm_ ## name ## _oformat = {\
450     #name,\
451     long_name,\
452     NULL,\
453     ext,\
454     0,\
455     codec,\
456     0,\
457     raw_write_header,\
458     raw_write_packet,\
459     raw_write_trailer,\
460 };
461 #endif //CONFIG_ENCODERS
462
463 #ifdef WORDS_BIGENDIAN
464 #define BE_DEF(s) s
465 #define LE_DEF(s) NULL
466 #else
467 #define BE_DEF(s) NULL
468 #define LE_DEF(s) s
469 #endif
470
471
472 PCMDEF(s16le, "pcm signed 16 bit little endian format", 
473        LE_DEF("sw"), CODEC_ID_PCM_S16LE)
474
475 PCMDEF(s16be, "pcm signed 16 bit big endian format", 
476        BE_DEF("sw"), CODEC_ID_PCM_S16BE)
477
478 PCMDEF(u16le, "pcm unsigned 16 bit little endian format", 
479        LE_DEF("uw"), CODEC_ID_PCM_U16LE)
480
481 PCMDEF(u16be, "pcm unsigned 16 bit big endian format", 
482        BE_DEF("uw"), CODEC_ID_PCM_U16BE)
483
484 PCMDEF(s8, "pcm signed 8 bit format", 
485        "sb", CODEC_ID_PCM_S8)
486
487 PCMDEF(u8, "pcm unsigned 8 bit format", 
488        "ub", CODEC_ID_PCM_U8)
489
490 PCMDEF(mulaw, "pcm mu law format", 
491        "ul", CODEC_ID_PCM_MULAW)
492
493 PCMDEF(alaw, "pcm A law format", 
494        "al", CODEC_ID_PCM_ALAW)
495
496 static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt)
497 {
498     int packet_size, ret, width, height;
499     AVStream *st = s->streams[0];
500
501     width = st->codec.width;
502     height = st->codec.height;
503
504     packet_size = avpicture_get_size(st->codec.pix_fmt, width, height);
505     if (packet_size < 0)
506         av_abort();
507
508     if (av_new_packet(pkt, packet_size) < 0)
509         return -EIO;
510
511     pkt->stream_index = 0;
512 #if 0
513     /* bypass buffered I/O */
514     ret = url_read(url_fileno(&s->pb), pkt->data, pkt->size);
515 #else
516     ret = get_buffer(&s->pb, pkt->data, pkt->size);
517 #endif
518     if (ret != pkt->size) {
519         av_free_packet(pkt);
520         return -EIO;
521     } else {
522         return 0;
523     }
524 }
525
526 AVInputFormat rawvideo_iformat = {
527     "rawvideo",
528     "raw video format",
529     0,
530     NULL,
531     raw_read_header,
532     rawvideo_read_packet,
533     raw_read_close,
534     .extensions = "yuv",
535     .value = CODEC_ID_RAWVIDEO,
536 };
537
538 #ifdef CONFIG_ENCODERS
539 AVOutputFormat rawvideo_oformat = {
540     "rawvideo",
541     "raw video format",
542     NULL,
543     "yuv",
544     0,
545     CODEC_ID_NONE,
546     CODEC_ID_RAWVIDEO,
547     raw_write_header,
548     raw_write_packet,
549     raw_write_trailer,
550 };
551 #endif //CONFIG_ENCODERS
552
553 #ifdef CONFIG_ENCODERS
554 static int null_write_packet(struct AVFormatContext *s, 
555                              int stream_index,
556                              const uint8_t *buf, int size, int64_t pts)
557 {
558     return 0;
559 }
560
561 AVOutputFormat null_oformat = {
562     "null",
563     "null video format",
564     NULL,
565     NULL,
566     0,
567 #ifdef WORDS_BIGENDIAN
568     CODEC_ID_PCM_S16BE,
569 #else
570     CODEC_ID_PCM_S16LE,
571 #endif
572     CODEC_ID_RAWVIDEO,
573     raw_write_header,
574     null_write_packet,
575     raw_write_trailer,
576     .flags = AVFMT_NOFILE | AVFMT_RAWPICTURE,
577 };
578 #endif //CONFIG_ENCODERS
579
580 #ifndef CONFIG_ENCODERS
581 #define av_register_output_format(format)
582 #endif
583 #ifndef CONFIG_DECODERS
584 #define av_register_input_format(format)
585 #endif
586
587 int raw_init(void)
588 {
589     av_register_input_format(&ac3_iformat);
590     av_register_output_format(&ac3_oformat);
591
592     av_register_input_format(&h263_iformat);
593     av_register_output_format(&h263_oformat);
594     
595     av_register_input_format(&m4v_iformat);
596     av_register_output_format(&m4v_oformat);
597     
598     av_register_input_format(&h264_iformat);
599     av_register_output_format(&h264_oformat);
600
601     av_register_input_format(&mpegvideo_iformat);
602     av_register_output_format(&mpeg1video_oformat);
603
604     av_register_input_format(&mjpeg_iformat);
605     av_register_output_format(&mjpeg_oformat);
606
607     av_register_input_format(&pcm_s16le_iformat);
608     av_register_output_format(&pcm_s16le_oformat);
609     av_register_input_format(&pcm_s16be_iformat);
610     av_register_output_format(&pcm_s16be_oformat);
611     av_register_input_format(&pcm_u16le_iformat);
612     av_register_output_format(&pcm_u16le_oformat);
613     av_register_input_format(&pcm_u16be_iformat);
614     av_register_output_format(&pcm_u16be_oformat);
615     av_register_input_format(&pcm_s8_iformat);
616     av_register_output_format(&pcm_s8_oformat);
617     av_register_input_format(&pcm_u8_iformat);
618     av_register_output_format(&pcm_u8_oformat);
619     av_register_input_format(&pcm_mulaw_iformat);
620     av_register_output_format(&pcm_mulaw_oformat);
621     av_register_input_format(&pcm_alaw_iformat);
622     av_register_output_format(&pcm_alaw_oformat);
623
624     av_register_input_format(&rawvideo_iformat);
625     av_register_output_format(&rawvideo_oformat);
626
627     av_register_output_format(&null_oformat);
628     return 0;
629 }