falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4230 Commits
32 Branches
283MB
Tree: a8d02f2bc9
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a8d02f2bc9'
${ noResults }
FFmpeg/libavformat/img2.c

440 lines
11KB
Raw Blame History 

  1. /*

  2.  * Image format

  3.  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard.

  4.  * Copyright (c) 2004 Michael Niedermayer

  5.  *

  6.  * This library is free software; you can redistribute it and/or

  7.  * modify it under the terms of the GNU Lesser General Public

  8.  * License as published by the Free Software Foundation; either

  9.  * version 2 of the License, or (at your option) any later version.

  10.  *

  11.  * This library is distributed in the hope that it will be useful,

  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  14.  * Lesser General Public License for more details.

  15.  *

  16.  * You should have received a copy of the GNU Lesser General Public

  17.  * License along with this library; if not, write to the Free Software

  18.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  19.  */

  20. #include "avformat.h"

  21. 

  22. /* XXX: this is a hack */

  23. extern int loop_input;

  24. 

  25. typedef struct {

  26.     int img_first;

  27.     int img_last;

  28.     int img_number;

  29.     int img_count;

  30.     int is_pipe;

  31.     char path[1024];

  32. } VideoData;

  33. 

  34. typedef struct {

  35.     enum CodecID id;

  36.     const char *str;

  37. } IdStrMap;

  38. 

  39. static const IdStrMap img_tags[] = {

  40.     { CODEC_ID_MJPEG     , "jpeg"},

  41.     { CODEC_ID_MJPEG     , "jpg"},

  42.     { CODEC_ID_LJPEG     , "ljpg"},

  43.     { CODEC_ID_PNG       , "png"},

  44.     { CODEC_ID_PPM       , "ppm"},

  45.     { CODEC_ID_PGM       , "pgm"},

  46.     { CODEC_ID_PGMYUV    , "pgmyuv"},

  47.     { CODEC_ID_PBM       , "pbm"},

  48.     { CODEC_ID_PAM       , "pam"},

  49.     { CODEC_ID_MPEG1VIDEO, "mpg1-img"},

  50.     { CODEC_ID_MPEG2VIDEO, "mpg2-img"},

  51.     { CODEC_ID_MPEG4     , "mpg4-img"},

  52.     { CODEC_ID_FFV1      , "ffv1-img"},

  53.     { CODEC_ID_RAWVIDEO  , "y"},

  54.     {0, NULL}

  55. };

  56. 

  57. static int sizes[][2] = {

  58.     { 640, 480 },

  59.     { 720, 480 },

  60.     { 720, 576 },

  61.     { 352, 288 },

  62.     { 352, 240 },

  63.     { 160, 128 },

  64.     { 512, 384 },

  65.     { 640, 352 },

  66.     { 640, 240 },

  67. };

  68. 

  69. static int infer_size(int *width_ptr, int *height_ptr, int size)

  70. {

  71.     int i;

  72. 

  73.     for(i=0;i<sizeof(sizes)/sizeof(sizes[0]);i++) {

  74.         if ((sizes[i][0] * sizes[i][1]) == size) {

  75.             *width_ptr = sizes[i][0];

  76.             *height_ptr = sizes[i][1];

  77.             return 0;

  78.         }

  79.     }

  80.     return -1;

  81. }

  82. static enum CodecID av_str2id(const IdStrMap *tags, const char *str)

  83. {

  84.     str= strrchr(str, '.');

  85.     if(!str) return CODEC_ID_NONE;

  86.     str++;

  87. 

  88.     while (tags->id) {

  89.         int i;

  90.         for(i=0; toupper(tags->str[i]) == toupper(str[i]); i++){

  91.             if(tags->str[i]==0 && str[i]==0)

  92.                 return tags->id;

  93.         }

  94. 

  95.         tags++;

  96.     }

  97.     return CODEC_ID_NONE;

  98. }

  99. 

  100. static const char *av_id2str(const IdStrMap *tags, enum CodecID id)

  101. {

  102.     while (tags->id) {

  103.         if(tags->id == id)

  104.             return tags->str;

  105.         tags++;

  106.     }

  107.     return NULL;

  108. }

  109. 

  110. /* return -1 if no image found */

  111. static int find_image_range(int *pfirst_index, int *plast_index, 

  112.                             const char *path)

  113. {

  114.     char buf[1024];

  115.     int range, last_index, range1, first_index;

  116. 

  117.     /* find the first image */

  118.     for(first_index = 0; first_index < 5; first_index++) {

  119.         if (get_frame_filename(buf, sizeof(buf), path, first_index) < 0){

  120.             *pfirst_index = 

  121.             *plast_index = 1;

  122.             return 0;

  123.         }

  124.         if (url_exist(buf))

  125.             break;

  126.     }

  127.     if (first_index == 5)

  128.         goto fail;

  129.     

  130.     /* find the last image */

  131.     last_index = first_index;

  132.     for(;;) {

  133.         range = 0;

  134.         for(;;) {

  135.             if (!range)

  136.                 range1 = 1;

  137.             else

  138.                 range1 = 2 * range;

  139.             if (get_frame_filename(buf, sizeof(buf), path, 

  140.                                    last_index + range1) < 0)

  141.                 goto fail;

  142.             if (!url_exist(buf))

  143.                 break;

  144.             range = range1;

  145.             /* just in case... */

  146.             if (range >= (1 << 30))

  147.                 goto fail;

  148.         }

  149.         /* we are sure than image last_index + range exists */

  150.         if (!range)

  151.             break;

  152.         last_index += range;

  153.     }

  154.     *pfirst_index = first_index;

  155.     *plast_index = last_index;

  156.     return 0;

  157.  fail:

  158.     return -1;

  159. }

  160. 

  161. 

  162. static int image_probe(AVProbeData *p)

  163. {

  164.     if (filename_number_test(p->filename) >= 0 && av_str2id(img_tags, p->filename))

  165.         return AVPROBE_SCORE_MAX;

  166.     else

  167.         return 0;

  168. }

  169. 

  170. enum CodecID av_guess_image2_codec(const char *filename){

  171.     return av_str2id(img_tags, filename);

  172. }

  173. 

  174. static int img_read_header(AVFormatContext *s1, AVFormatParameters *ap)

  175. {

  176.     VideoData *s = s1->priv_data;

  177.     int first_index, last_index;

  178.     AVStream *st;

  179. 

  180.     s1->ctx_flags |= AVFMTCTX_NOHEADER;

  181. 

  182.     st = av_new_stream(s1, 0);

  183.     if (!st) {

  184.         return -ENOMEM;

  185.     }

  186. 

  187.     pstrcpy(s->path, sizeof(s->path), s1->filename);

  188.     s->img_number = 0;

  189.     s->img_count = 0;

  190.     

  191.     /* find format */

  192.     if (s1->iformat->flags & AVFMT_NOFILE)

  193.         s->is_pipe = 0;

  194.     else{

  195.         s->is_pipe = 1;

  196.         st->need_parsing= 1;

  197.     }

  198.         

  199.     if (!ap || !ap->frame_rate) {

  200.         st->codec.frame_rate      = 25;

  201.         st->codec.frame_rate_base = 1;

  202.     } else {

  203.         st->codec.frame_rate      = ap->frame_rate;

  204.         st->codec.frame_rate_base = ap->frame_rate_base;

  205.     }

  206.     

  207.     if(ap && ap->width && ap->height){

  208.         st->codec.width = ap->width;

  209.         st->codec.height= ap->height;

  210.     }

  211.     

  212.     if (!s->is_pipe) {

  213.         if (find_image_range(&first_index, &last_index, s->path) < 0)

  214.             return AVERROR_IO;

  215.         s->img_first = first_index;

  216.         s->img_last = last_index;

  217.         s->img_number = first_index;

  218.         /* compute duration */

  219.         st->start_time = 0;

  220.         st->duration = ((int64_t)AV_TIME_BASE * 

  221.                         (last_index - first_index + 1) * 

  222.                         st->codec.frame_rate_base) / st->codec.frame_rate;

  223.     }

  224.     

  225.     if(ap->video_codec_id){

  226.         st->codec.codec_type = CODEC_TYPE_VIDEO;

  227.         st->codec.codec_id = ap->video_codec_id;

  228.     }else if(ap->audio_codec_id){

  229.         st->codec.codec_type = CODEC_TYPE_AUDIO;

  230.         st->codec.codec_id = ap->audio_codec_id;

  231.     }else{

  232.         st->codec.codec_type = CODEC_TYPE_VIDEO;

  233.         st->codec.codec_id = av_str2id(img_tags, s->path);

  234.     }

  235. 

  236.     return 0;

  237. }

  238. 

  239. static int img_read_packet(AVFormatContext *s1, AVPacket *pkt)

  240. {

  241.     VideoData *s = s1->priv_data;

  242.     char filename[1024];

  243.     int i;

  244.     int size[3]={0}, ret[3]={0};

  245.     ByteIOContext f1[3], *f[3]= {&f1[0], &f1[1], &f1[2]};

  246.     AVCodecContext *codec= &s1->streams[0]->codec;

  247. 

  248.     if (!s->is_pipe) {

  249.         /* loop over input */

  250.         if (loop_input && s->img_number > s->img_last) {

  251.             s->img_number = s->img_first;

  252.         }

  253.         if (get_frame_filename(filename, sizeof(filename),

  254.                                s->path, s->img_number)<0 && s->img_number > 1)

  255.             return AVERROR_IO;

  256.         for(i=0; i<3; i++){

  257.             if (url_fopen(f[i], filename, URL_RDONLY) < 0)

  258.                 return AVERROR_IO;

  259.             size[i]= url_filesize(url_fileno(f[i]));

  260.             

  261.             if(codec->codec_id != CODEC_ID_RAWVIDEO)

  262.                 break;

  263.             filename[ strlen(filename) - 1 ]= 'U' + i;

  264.         }

  265.         

  266.         if(codec->codec_id == CODEC_ID_RAWVIDEO && !codec->width)

  267.             infer_size(&codec->width, &codec->height, size[0]);

  268.     } else {

  269.         f[0] = &s1->pb;

  270.         if (url_feof(f[0]))

  271.             return AVERROR_IO;

  272.         size[0]= 4096;

  273.     }

  274. 

  275.     av_new_packet(pkt, size[0] + size[1] + size[2]);

  276.     pkt->stream_index = 0;

  277.     pkt->flags |= PKT_FLAG_KEY;

  278. 

  279.     pkt->size= 0;

  280.     for(i=0; i<3; i++){

  281.         if(size[i]){

  282.             ret[i]= get_buffer(f[i], pkt->data + pkt->size, size[i]);

  283.             if (!s->is_pipe)

  284.                 url_fclose(f[i]);

  285.             if(ret[i]>0)

  286.                 pkt->size += ret[i];

  287.         }

  288.     }

  289. 

  290.     if (ret[0] <= 0 || ret[1]<0 || ret[2]<0) {

  291.         av_free_packet(pkt);

  292.         return AVERROR_IO; /* signal EOF */

  293.     } else {

  294.         s->img_count++;

  295.         s->img_number++;

  296.         return 0;

  297.     }

  298. }

  299. 

  300. static int img_read_close(AVFormatContext *s1)

  301. {

  302.     return 0;

  303. }

  304. 

  305. /******************************************************/

  306. /* image output */

  307. 

  308. static int img_write_header(AVFormatContext *s)

  309. {

  310.     VideoData *img = s->priv_data;

  311. 

  312.     img->img_number = 1;

  313.     pstrcpy(img->path, sizeof(img->path), s->filename);

  314. 

  315.     /* find format */

  316.     if (s->oformat->flags & AVFMT_NOFILE)

  317.         img->is_pipe = 0;

  318.     else

  319.         img->is_pipe = 1;

  320.         

  321.     return 0;

  322. }

  323. 

  324. static int img_write_packet(AVFormatContext *s, AVPacket *pkt)

  325. {

  326.     VideoData *img = s->priv_data;

  327.     ByteIOContext pb1[3], *pb[3]= {&pb1[0], &pb1[1], &pb1[2]};

  328.     char filename[1024];

  329.     AVCodecContext *codec= &s->streams[ pkt->stream_index ]->codec;

  330.     int i;

  331. 

  332.     if (!img->is_pipe) {

  333.         if (get_frame_filename(filename, sizeof(filename), 

  334.                                img->path, img->img_number) < 0 && img->img_number>1)

  335.             return AVERROR_IO;

  336.         for(i=0; i<3; i++){

  337.             if (url_fopen(pb[i], filename, URL_WRONLY) < 0)

  338.                 return AVERROR_IO;

  339.         

  340.             if(codec->codec_id != CODEC_ID_RAWVIDEO)

  341.                 break;

  342.             filename[ strlen(filename) - 1 ]= 'U' + i;

  343.         }

  344.     } else {

  345.         pb[0] = &s->pb;

  346.     }

  347.     

  348.     if(codec->codec_id == CODEC_ID_RAWVIDEO){

  349.         int size = (codec->width * codec->height)>>2;

  350.         put_buffer(pb[0], pkt->data         , 4*size);

  351.         put_buffer(pb[1], pkt->data + 4*size,   size);

  352.         put_buffer(pb[2], pkt->data + 5*size,   size);

  353.         put_flush_packet(pb[1]);

  354.         put_flush_packet(pb[2]);

  355.         url_fclose(pb[1]);

  356.         url_fclose(pb[2]);

  357.     }else{

  358.         put_buffer(pb[0], pkt->data, pkt->size);

  359.     }

  360.     put_flush_packet(pb[0]);

  361.     if (!img->is_pipe) {

  362.         url_fclose(pb[0]);

  363.     }

  364. 

  365.     img->img_number++;

  366.     return 0;

  367. }

  368. 

  369. static int img_write_trailer(AVFormatContext *s)

  370. {

  371.     return 0;

  372. }

  373. 

  374. /* input */

  375. 

  376. static AVInputFormat image2_iformat = {

  377.     "image2",

  378.     "image2 sequence",

  379.     sizeof(VideoData),

  380.     image_probe,

  381.     img_read_header,

  382.     img_read_packet,

  383.     img_read_close,

  384.     NULL,

  385.     NULL,

  386.     AVFMT_NOFILE,

  387. };

  388. 

  389. static AVInputFormat image2pipe_iformat = {

  390.     "image2pipe",

  391.     "piped image2 sequence",

  392.     sizeof(VideoData),

  393.     NULL, /* no probe */

  394.     img_read_header,

  395.     img_read_packet,

  396.     img_read_close,

  397.     NULL,

  398. };

  399. 

  400. 

  401. /* output */

  402. 

  403. static AVOutputFormat image2_oformat = {

  404.     "image2",

  405.     "image2 sequence",

  406.     "",

  407.     "",

  408.     sizeof(VideoData),

  409.     CODEC_ID_NONE,

  410.     CODEC_ID_MJPEG,

  411.     img_write_header,

  412.     img_write_packet,

  413.     img_write_trailer,

  414.     AVFMT_NOFILE,

  415. };

  416. 

  417. static AVOutputFormat image2pipe_oformat = {

  418.     "image2pipe",

  419.     "piped image2 sequence",

  420.     "",

  421.     "",

  422.     sizeof(VideoData),

  423.     CODEC_ID_NONE,

  424.     CODEC_ID_MJPEG,

  425.     img_write_header,

  426.     img_write_packet,

  427.     img_write_trailer,

  428. };

  429. 

  430. int img2_init(void)

  431. {

  432.     av_register_input_format(&image2_iformat);

  433.     av_register_output_format(&image2_oformat);

  434. 

  435.     av_register_input_format(&image2pipe_iformat);

  436.     av_register_output_format(&image2pipe_oformat);

  437.     

  438.     return 0;

  439. }