2ae744943d125ace6f82bc9af3e744430a9e4ce6
[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, AVPacket *pkt)
29 {
30     put_buffer(&s->pb, pkt->data, pkt->size);
31     put_flush_packet(&s->pb);
32     return 0;
33 }
34
35 static int raw_write_trailer(struct AVFormatContext *s)
36 {
37     return 0;
38 }
39 #endif //CONFIG_ENCODERS
40
41 /* raw input */
42 static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap)
43 {
44     AVStream *st;
45     int id;
46
47     st = av_new_stream(s, 0);
48     if (!st)
49         return AVERROR_NOMEM;
50     if (ap) {
51         id = s->iformat->value;
52         if (id == CODEC_ID_RAWVIDEO) {
53             st->codec.codec_type = CODEC_TYPE_VIDEO;
54         } else {
55             st->codec.codec_type = CODEC_TYPE_AUDIO;
56         }
57         st->codec.codec_id = id;
58
59         switch(st->codec.codec_type) {
60         case CODEC_TYPE_AUDIO:
61             st->codec.sample_rate = ap->sample_rate;
62             st->codec.channels = ap->channels;
63             av_set_pts_info(st, 64, 1, st->codec.sample_rate);
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 AVERROR_IO;
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 AVERROR_IO;
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 AVERROR_IO;
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 AVERROR_IO;
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, int flags)
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_rnd(timestamp * byte_rate, 
163                          st->time_base.num, 
164                          st->time_base.den * (int64_t)block_align,
165                          (flags & AVSEEK_FLAG_BACKWARD) ? AV_ROUND_DOWN : AV_ROUND_UP);
166     pos *= block_align;
167
168     /* recompute exact position */
169     st->cur_dts = av_rescale(pos, st->time_base.den, byte_rate * (int64_t)st->time_base.num);
170     url_fseek(&s->pb, pos + s->data_offset, SEEK_SET);
171     return 0;
172 }
173
174 /* ac3 read */
175 static int ac3_read_header(AVFormatContext *s,
176                            AVFormatParameters *ap)
177 {
178     AVStream *st;
179
180     st = av_new_stream(s, 0);
181     if (!st)
182         return AVERROR_NOMEM;
183
184     st->codec.codec_type = CODEC_TYPE_AUDIO;
185     st->codec.codec_id = CODEC_ID_AC3;
186     st->need_parsing = 1;
187     /* the parameters will be extracted from the compressed bitstream */
188     return 0;
189 }
190
191 /* dts read */
192 static int dts_read_header(AVFormatContext *s,
193                            AVFormatParameters *ap)
194 {
195     AVStream *st;
196
197     st = av_new_stream(s, 0);
198     if (!st)
199         return AVERROR_NOMEM;
200
201     st->codec.codec_type = CODEC_TYPE_AUDIO;
202     st->codec.codec_id = CODEC_ID_DTS;
203     st->need_parsing = 1;
204     /* the parameters will be extracted from the compressed bitstream */
205     return 0;
206 }
207
208 /* mpeg1/h263 input */
209 static int video_read_header(AVFormatContext *s,
210                              AVFormatParameters *ap)
211 {
212     AVStream *st;
213
214     st = av_new_stream(s, 0);
215     if (!st)
216         return AVERROR_NOMEM;
217
218     st->codec.codec_type = CODEC_TYPE_VIDEO;
219     st->codec.codec_id = s->iformat->value;
220     st->need_parsing = 1;
221
222     /* for mjpeg, specify frame rate */
223     /* for mpeg4 specify it too (most mpeg4 streams dont have the fixed_vop_rate set ...)*/
224     if (st->codec.codec_id == CODEC_ID_MJPEG || 
225         st->codec.codec_id == CODEC_ID_MPEG4) {
226         if (ap && ap->frame_rate) {
227             st->codec.frame_rate      = ap->frame_rate;
228             st->codec.frame_rate_base = ap->frame_rate_base;
229         } else {
230             st->codec.frame_rate      = 25;
231             st->codec.frame_rate_base = 1;
232         }
233     }
234     return 0;
235 }
236
237 #define SEQ_START_CODE          0x000001b3
238 #define GOP_START_CODE          0x000001b8
239 #define PICTURE_START_CODE      0x00000100
240
241 /* XXX: improve that by looking at several start codes */
242 static int mpegvideo_probe(AVProbeData *p)
243 {
244     int code;
245     const uint8_t *d;
246
247     /* we search the first start code. If it is a sequence, gop or
248        picture start code then we decide it is an mpeg video
249        stream. We do not send highest value to give a chance to mpegts */
250     /* NOTE: the search range was restricted to avoid too many false
251        detections */
252
253     if (p->buf_size < 6)
254         return 0;
255     d = p->buf;
256     code = (d[0] << 24) | (d[1] << 16) | (d[2] << 8) | (d[3]);
257     if ((code & 0xffffff00) == 0x100) {
258         if (code == SEQ_START_CODE ||
259             code == GOP_START_CODE ||
260             code == PICTURE_START_CODE)
261             return 50 - 1;
262         else
263             return 0;
264     }
265     return 0;
266 }
267
268 static int h263_probe(AVProbeData *p)
269 {
270     int code;
271     const uint8_t *d;
272
273     if (p->buf_size < 6)
274         return 0;
275     d = p->buf;
276     code = (d[0] << 14) | (d[1] << 6) | (d[2] >> 2);
277     if (code == 0x20) {
278         return 50;
279     }
280     return 0;
281 }
282
283 static int h261_probe(AVProbeData *p)
284 {
285     int code;
286     const uint8_t *d;
287
288     if (p->buf_size < 6)
289         return 0;
290     d = p->buf;
291     code = (d[0] << 12) | (d[1] << 4) | (d[2] >> 4);
292     if (code == 0x10) {
293         return 50;
294     }
295     return 0;
296 }
297
298 AVInputFormat ac3_iformat = {
299     "ac3",
300     "raw ac3",
301     0,
302     NULL,
303     ac3_read_header,
304     raw_read_partial_packet,
305     raw_read_close,
306     .extensions = "ac3",
307 };
308
309 #ifdef CONFIG_ENCODERS
310 AVOutputFormat ac3_oformat = {
311     "ac3",
312     "raw ac3",
313     "audio/x-ac3", 
314     "ac3",
315     0,
316     CODEC_ID_AC3,
317     0,
318     raw_write_header,
319     raw_write_packet,
320     raw_write_trailer,
321 };
322 #endif //CONFIG_ENCODERS
323
324 AVInputFormat dts_iformat = {
325     "dts",
326     "raw dts",
327     0,
328     NULL,
329     dts_read_header,
330     raw_read_partial_packet,
331     raw_read_close,
332     .extensions = "dts",
333 };
334
335 AVInputFormat h261_iformat = {
336     "h261",
337     "raw h261",
338     0,
339     h261_probe,
340     video_read_header,
341     raw_read_partial_packet,
342     raw_read_close,
343     .extensions = "h261",
344     .value = CODEC_ID_H261,
345 };
346
347 AVInputFormat h263_iformat = {
348     "h263",
349     "raw h263",
350     0,
351     h263_probe,
352     video_read_header,
353     raw_read_partial_packet,
354     raw_read_close,
355 //    .extensions = "h263", //FIXME remove after writing mpeg4_probe
356     .value = CODEC_ID_H263,
357 };
358
359 #ifdef CONFIG_ENCODERS
360 AVOutputFormat h263_oformat = {
361     "h263",
362     "raw h263",
363     "video/x-h263",
364     "h263",
365     0,
366     0,
367     CODEC_ID_H263,
368     raw_write_header,
369     raw_write_packet,
370     raw_write_trailer,
371 };
372 #endif //CONFIG_ENCODERS
373
374 AVInputFormat m4v_iformat = {
375     "m4v",
376     "raw MPEG4 video format",
377     0,
378     NULL /*mpegvideo_probe*/,
379     video_read_header,
380     raw_read_partial_packet,
381     raw_read_close,
382     .extensions = "m4v", //FIXME remove after writing mpeg4_probe
383     .value = CODEC_ID_MPEG4,
384 };
385
386 #ifdef CONFIG_ENCODERS
387 AVOutputFormat m4v_oformat = {
388     "m4v",
389     "raw MPEG4 video format",
390     NULL,
391     "m4v",
392     0,
393     CODEC_ID_NONE,
394     CODEC_ID_MPEG4,
395     raw_write_header,
396     raw_write_packet,
397     raw_write_trailer,
398 };
399 #endif //CONFIG_ENCODERS
400
401 AVInputFormat h264_iformat = {
402     "h264",
403     "raw H264 video format",
404     0,
405     NULL /*mpegvideo_probe*/,
406     video_read_header,
407     raw_read_partial_packet,
408     raw_read_close,
409     .extensions = "h26l,h264", //FIXME remove after writing mpeg4_probe
410     .value = CODEC_ID_H264,
411 };
412
413 #ifdef CONFIG_ENCODERS
414 AVOutputFormat h264_oformat = {
415     "h264",
416     "raw H264 video format",
417     NULL,
418     "h264",
419     0,
420     CODEC_ID_NONE,
421     CODEC_ID_H264,
422     raw_write_header,
423     raw_write_packet,
424     raw_write_trailer,
425 };
426 #endif //CONFIG_ENCODERS
427
428 AVInputFormat mpegvideo_iformat = {
429     "mpegvideo",
430     "MPEG video",
431     0,
432     mpegvideo_probe,
433     video_read_header,
434     raw_read_partial_packet,
435     raw_read_close,
436     .value = CODEC_ID_MPEG1VIDEO,
437 };
438
439 #ifdef CONFIG_ENCODERS
440 AVOutputFormat mpeg1video_oformat = {
441     "mpeg1video",
442     "MPEG video",
443     "video/x-mpeg",
444     "mpg,mpeg",
445     0,
446     0,
447     CODEC_ID_MPEG1VIDEO,
448     raw_write_header,
449     raw_write_packet,
450     raw_write_trailer,
451 };
452 #endif //CONFIG_ENCODERS
453
454 AVInputFormat mjpeg_iformat = {
455     "mjpeg",
456     "MJPEG video",
457     0,
458     NULL,
459     video_read_header,
460     raw_read_partial_packet,
461     raw_read_close,
462     .extensions = "mjpg,mjpeg",
463     .value = CODEC_ID_MJPEG,
464 };
465
466 #ifdef CONFIG_ENCODERS
467 AVOutputFormat mjpeg_oformat = {
468     "mjpeg",
469     "MJPEG video",
470     "video/x-mjpeg",
471     "mjpg,mjpeg",
472     0,
473     0,
474     CODEC_ID_MJPEG,
475     raw_write_header,
476     raw_write_packet,
477     raw_write_trailer,
478 };
479 #endif //CONFIG_ENCODERS
480
481 /* pcm formats */
482
483 #define PCMINPUTDEF(name, long_name, ext, codec) \
484 AVInputFormat pcm_ ## name ## _iformat = {\
485     #name,\
486     long_name,\
487     0,\
488     NULL,\
489     raw_read_header,\
490     raw_read_packet,\
491     raw_read_close,\
492     pcm_read_seek,\
493     .extensions = ext,\
494     .value = codec,\
495 };
496
497 #if !defined(CONFIG_ENCODERS) && defined(CONFIG_DECODERS)
498
499 #define PCMDEF(name, long_name, ext, codec) \
500     PCMINPUTDEF(name, long_name, ext, codec)
501
502 #else
503
504 #define PCMDEF(name, long_name, ext, codec) \
505     PCMINPUTDEF(name, long_name, ext, codec)\
506 \
507 AVOutputFormat pcm_ ## name ## _oformat = {\
508     #name,\
509     long_name,\
510     NULL,\
511     ext,\
512     0,\
513     codec,\
514     0,\
515     raw_write_header,\
516     raw_write_packet,\
517     raw_write_trailer,\
518 };
519 #endif //CONFIG_ENCODERS
520
521 #ifdef WORDS_BIGENDIAN
522 #define BE_DEF(s) s
523 #define LE_DEF(s) NULL
524 #else
525 #define BE_DEF(s) NULL
526 #define LE_DEF(s) s
527 #endif
528
529
530 PCMDEF(s16le, "pcm signed 16 bit little endian format", 
531        LE_DEF("sw"), CODEC_ID_PCM_S16LE)
532
533 PCMDEF(s16be, "pcm signed 16 bit big endian format", 
534        BE_DEF("sw"), CODEC_ID_PCM_S16BE)
535
536 PCMDEF(u16le, "pcm unsigned 16 bit little endian format", 
537        LE_DEF("uw"), CODEC_ID_PCM_U16LE)
538
539 PCMDEF(u16be, "pcm unsigned 16 bit big endian format", 
540        BE_DEF("uw"), CODEC_ID_PCM_U16BE)
541
542 PCMDEF(s8, "pcm signed 8 bit format", 
543        "sb", CODEC_ID_PCM_S8)
544
545 PCMDEF(u8, "pcm unsigned 8 bit format", 
546        "ub", CODEC_ID_PCM_U8)
547
548 PCMDEF(mulaw, "pcm mu law format", 
549        "ul", CODEC_ID_PCM_MULAW)
550
551 PCMDEF(alaw, "pcm A law format", 
552        "al", CODEC_ID_PCM_ALAW)
553
554 static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt)
555 {
556     int packet_size, ret, width, height;
557     AVStream *st = s->streams[0];
558
559     width = st->codec.width;
560     height = st->codec.height;
561
562     packet_size = avpicture_get_size(st->codec.pix_fmt, width, height);
563     if (packet_size < 0)
564         return -1;
565
566     if (av_new_packet(pkt, packet_size) < 0)
567         return AVERROR_IO;
568
569     pkt->stream_index = 0;
570 #if 0
571     /* bypass buffered I/O */
572     ret = url_read(url_fileno(&s->pb), pkt->data, pkt->size);
573 #else
574     ret = get_buffer(&s->pb, pkt->data, pkt->size);
575 #endif
576     if (ret != pkt->size) {
577         av_free_packet(pkt);
578         return AVERROR_IO;
579     } else {
580         return 0;
581     }
582 }
583
584 AVInputFormat rawvideo_iformat = {
585     "rawvideo",
586     "raw video format",
587     0,
588     NULL,
589     raw_read_header,
590     rawvideo_read_packet,
591     raw_read_close,
592     .extensions = "yuv",
593     .value = CODEC_ID_RAWVIDEO,
594 };
595
596 #ifdef CONFIG_ENCODERS
597 AVOutputFormat rawvideo_oformat = {
598     "rawvideo",
599     "raw video format",
600     NULL,
601     "yuv",
602     0,
603     CODEC_ID_NONE,
604     CODEC_ID_RAWVIDEO,
605     raw_write_header,
606     raw_write_packet,
607     raw_write_trailer,
608 };
609 #endif //CONFIG_ENCODERS
610
611 #ifdef CONFIG_ENCODERS
612 static int null_write_packet(struct AVFormatContext *s, AVPacket *pkt)
613 {
614     return 0;
615 }
616
617 AVOutputFormat null_oformat = {
618     "null",
619     "null video format",
620     NULL,
621     NULL,
622     0,
623 #ifdef WORDS_BIGENDIAN
624     CODEC_ID_PCM_S16BE,
625 #else
626     CODEC_ID_PCM_S16LE,
627 #endif
628     CODEC_ID_RAWVIDEO,
629     raw_write_header,
630     null_write_packet,
631     raw_write_trailer,
632     .flags = AVFMT_NOFILE | AVFMT_RAWPICTURE,
633 };
634 #endif //CONFIG_ENCODERS
635
636 #ifndef CONFIG_ENCODERS
637 #define av_register_output_format(format)
638 #endif
639 #ifndef CONFIG_DECODERS
640 #define av_register_input_format(format)
641 #endif
642
643 int raw_init(void)
644 {
645     av_register_input_format(&ac3_iformat);
646     av_register_output_format(&ac3_oformat);
647
648     av_register_input_format(&dts_iformat);
649
650     av_register_input_format(&h261_iformat);
651
652     av_register_input_format(&h263_iformat);
653     av_register_output_format(&h263_oformat);
654     
655     av_register_input_format(&m4v_iformat);
656     av_register_output_format(&m4v_oformat);
657     
658     av_register_input_format(&h264_iformat);
659     av_register_output_format(&h264_oformat);
660
661     av_register_input_format(&mpegvideo_iformat);
662     av_register_output_format(&mpeg1video_oformat);
663
664     av_register_input_format(&mjpeg_iformat);
665     av_register_output_format(&mjpeg_oformat);
666
667     av_register_input_format(&pcm_s16le_iformat);
668     av_register_output_format(&pcm_s16le_oformat);
669     av_register_input_format(&pcm_s16be_iformat);
670     av_register_output_format(&pcm_s16be_oformat);
671     av_register_input_format(&pcm_u16le_iformat);
672     av_register_output_format(&pcm_u16le_oformat);
673     av_register_input_format(&pcm_u16be_iformat);
674     av_register_output_format(&pcm_u16be_oformat);
675     av_register_input_format(&pcm_s8_iformat);
676     av_register_output_format(&pcm_s8_oformat);
677     av_register_input_format(&pcm_u8_iformat);
678     av_register_output_format(&pcm_u8_oformat);
679     av_register_input_format(&pcm_mulaw_iformat);
680     av_register_output_format(&pcm_mulaw_oformat);
681     av_register_input_format(&pcm_alaw_iformat);
682     av_register_output_format(&pcm_alaw_oformat);
683
684     av_register_input_format(&rawvideo_iformat);
685     av_register_output_format(&rawvideo_oformat);
686
687     av_register_output_format(&null_oformat);
688     return 0;
689 }