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.
8611 Commits
32 Branches
283MB
Tree: 25f5f17fbd
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '25f5f17fbd'
${ noResults }
FFmpeg/libavformat/ffm.c

795 lines
23KB
Raw Blame History 

  1. /*

  2.  * FFM (ffserver live feed) muxer and demuxer

  3.  * Copyright (c) 2001 Fabrice Bellard.

  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. #include "avformat.h"

  22. #include <unistd.h>

  23. 

  24. /* The FFM file is made of blocks of fixed size */

  25. #define FFM_HEADER_SIZE 14

  26. #define PACKET_ID       0x666d

  27. 

  28. /* each packet contains frames (which can span several packets */

  29. #define FRAME_HEADER_SIZE    8

  30. #define FLAG_KEY_FRAME       0x01

  31. 

  32. typedef struct FFMStream {

  33.     int64_t pts;

  34. } FFMStream;

  35. 

  36. enum {

  37.     READ_HEADER,

  38.     READ_DATA,

  39. };

  40. 

  41. typedef struct FFMContext {

  42.     /* only reading mode */

  43.     offset_t write_index, file_size;

  44.     int read_state;

  45.     uint8_t header[FRAME_HEADER_SIZE];

  46. 

  47.     /* read and write */

  48.     int first_packet; /* true if first packet, needed to set the discontinuity tag */

  49.     int first_frame_in_packet; /* true if first frame in packet, needed to know if PTS information is valid */

  50.     int packet_size;

  51.     int frame_offset;

  52.     int64_t pts;

  53.     uint8_t *packet_ptr, *packet_end;

  54.     uint8_t packet[FFM_PACKET_SIZE];

  55. } FFMContext;

  56. 

  57. static int64_t get_pts(AVFormatContext *s, offset_t pos);

  58. 

  59. /* disable pts hack for testing */

  60. int ffm_nopts = 0;

  61. 

  62. #ifdef CONFIG_MUXERS

  63. static void flush_packet(AVFormatContext *s)

  64. {

  65.     FFMContext *ffm = s->priv_data;

  66.     int fill_size, h;

  67.     ByteIOContext *pb = &s->pb;

  68. 

  69.     fill_size = ffm->packet_end - ffm->packet_ptr;

  70.     memset(ffm->packet_ptr, 0, fill_size);

  71. 

  72.     if (url_ftell(pb) % ffm->packet_size)

  73.         av_abort();

  74. 

  75.     /* put header */

  76.     put_be16(pb, PACKET_ID);

  77.     put_be16(pb, fill_size);

  78.     put_be64(pb, ffm->pts);

  79.     h = ffm->frame_offset;

  80.     if (ffm->first_packet)

  81.         h |= 0x8000;

  82.     put_be16(pb, h);

  83.     put_buffer(pb, ffm->packet, ffm->packet_end - ffm->packet);

  84.     put_flush_packet(pb);

  85. 

  86.     /* prepare next packet */

  87.     ffm->frame_offset = 0; /* no key frame */

  88.     ffm->pts = 0; /* no pts */

  89.     ffm->packet_ptr = ffm->packet;

  90.     ffm->first_packet = 0;

  91. }

  92. 

  93. /* 'first' is true if first data of a frame */

  94. static void ffm_write_data(AVFormatContext *s,

  95.                            const uint8_t *buf, int size,

  96.                            int64_t pts, int first)

  97. {

  98.     FFMContext *ffm = s->priv_data;

  99.     int len;

  100. 

  101.     if (first && ffm->frame_offset == 0)

  102.         ffm->frame_offset = ffm->packet_ptr - ffm->packet + FFM_HEADER_SIZE;

  103.     if (first && ffm->pts == 0)

  104.         ffm->pts = pts;

  105. 

  106.     /* write as many packets as needed */

  107.     while (size > 0) {

  108.         len = ffm->packet_end - ffm->packet_ptr;

  109.         if (len > size)

  110.             len = size;

  111.         memcpy(ffm->packet_ptr, buf, len);

  112. 

  113.         ffm->packet_ptr += len;

  114.         buf += len;

  115.         size -= len;

  116.         if (ffm->packet_ptr >= ffm->packet_end) {

  117.             /* special case : no pts in packet : we leave the current one */

  118.             if (ffm->pts == 0)

  119.                 ffm->pts = pts;

  120. 

  121.             flush_packet(s);

  122.         }

  123.     }

  124. }

  125. 

  126. static int ffm_write_header(AVFormatContext *s)

  127. {

  128.     FFMContext *ffm = s->priv_data;

  129.     AVStream *st;

  130.     FFMStream *fst;

  131.     ByteIOContext *pb = &s->pb;

  132.     AVCodecContext *codec;

  133.     int bit_rate, i;

  134. 

  135.     ffm->packet_size = FFM_PACKET_SIZE;

  136. 

  137.     /* header */

  138.     put_le32(pb, MKTAG('F', 'F', 'M', '1'));

  139.     put_be32(pb, ffm->packet_size);

  140.     /* XXX: store write position in other file ? */

  141.     put_be64(pb, ffm->packet_size); /* current write position */

  142. 

  143.     put_be32(pb, s->nb_streams);

  144.     bit_rate = 0;

  145.     for(i=0;i<s->nb_streams;i++) {

  146.         st = s->streams[i];

  147.         bit_rate += st->codec->bit_rate;

  148.     }

  149.     put_be32(pb, bit_rate);

  150. 

  151.     /* list of streams */

  152.     for(i=0;i<s->nb_streams;i++) {

  153.         st = s->streams[i];

  154.         fst = av_mallocz(sizeof(FFMStream));

  155.         if (!fst)

  156.             goto fail;

  157.         av_set_pts_info(st, 64, 1, 1000000);

  158.         st->priv_data = fst;

  159. 

  160.         codec = st->codec;

  161.         /* generic info */

  162.         put_be32(pb, codec->codec_id);

  163.         put_byte(pb, codec->codec_type);

  164.         put_be32(pb, codec->bit_rate);

  165.         put_be32(pb, st->quality);

  166.         put_be32(pb, codec->flags);

  167.         put_be32(pb, codec->flags2);

  168.         put_be32(pb, codec->debug);

  169.         /* specific info */

  170.         switch(codec->codec_type) {

  171.         case CODEC_TYPE_VIDEO:

  172.             put_be32(pb, codec->time_base.num);

  173.             put_be32(pb, codec->time_base.den);

  174.             put_be16(pb, codec->width);

  175.             put_be16(pb, codec->height);

  176.             put_be16(pb, codec->gop_size);

  177.             put_be32(pb, codec->pix_fmt);

  178.             put_byte(pb, codec->qmin);

  179.             put_byte(pb, codec->qmax);

  180.             put_byte(pb, codec->max_qdiff);

  181.             put_be16(pb, (int) (codec->qcompress * 10000.0));

  182.             put_be16(pb, (int) (codec->qblur * 10000.0));

  183.             put_be32(pb, codec->bit_rate_tolerance);

  184.             put_strz(pb, codec->rc_eq);

  185.             put_be32(pb, codec->rc_max_rate);

  186.             put_be32(pb, codec->rc_min_rate);

  187.             put_be32(pb, codec->rc_buffer_size);

  188.             put_be64(pb, av_dbl2int(codec->i_quant_factor));

  189.             put_be64(pb, av_dbl2int(codec->b_quant_factor));

  190.             put_be64(pb, av_dbl2int(codec->i_quant_offset));

  191.             put_be64(pb, av_dbl2int(codec->b_quant_offset));

  192.             put_be32(pb, codec->dct_algo);

  193.             put_be32(pb, codec->strict_std_compliance);

  194.             put_be32(pb, codec->max_b_frames);

  195.             put_be32(pb, codec->luma_elim_threshold);

  196.             put_be32(pb, codec->chroma_elim_threshold);

  197.             put_be32(pb, codec->mpeg_quant);

  198.             put_be32(pb, codec->intra_dc_precision);

  199.             put_be32(pb, codec->me_method);

  200.             put_be32(pb, codec->mb_decision);

  201.             put_be32(pb, codec->nsse_weight);

  202.             put_be32(pb, codec->frame_skip_cmp);

  203.             put_be64(pb, av_dbl2int(codec->rc_buffer_aggressivity));

  204.             put_be32(pb, codec->codec_tag);

  205.             break;

  206.         case CODEC_TYPE_AUDIO:

  207.             put_be32(pb, codec->sample_rate);

  208.             put_le16(pb, codec->channels);

  209.             put_le16(pb, codec->frame_size);

  210.             break;

  211.         default:

  212.             return -1;

  213.         }

  214.         /* hack to have real time */

  215.         if (ffm_nopts)

  216.             fst->pts = 0;

  217.         else

  218.             fst->pts = av_gettime();

  219.     }

  220. 

  221.     /* flush until end of block reached */

  222.     while ((url_ftell(pb) % ffm->packet_size) != 0)

  223.         put_byte(pb, 0);

  224. 

  225.     put_flush_packet(pb);

  226. 

  227.     /* init packet mux */

  228.     ffm->packet_ptr = ffm->packet;

  229.     ffm->packet_end = ffm->packet + ffm->packet_size - FFM_HEADER_SIZE;

  230.     assert(ffm->packet_end >= ffm->packet);

  231.     ffm->frame_offset = 0;

  232.     ffm->pts = 0;

  233.     ffm->first_packet = 1;

  234. 

  235.     return 0;

  236.  fail:

  237.     for(i=0;i<s->nb_streams;i++) {

  238.         st = s->streams[i];

  239.         av_freep(&st->priv_data);

  240.     }

  241.     return -1;

  242. }

  243. 

  244. static int ffm_write_packet(AVFormatContext *s, AVPacket *pkt)

  245. {

  246.     AVStream *st = s->streams[pkt->stream_index];

  247.     FFMStream *fst = st->priv_data;

  248.     int64_t pts;

  249.     uint8_t header[FRAME_HEADER_SIZE];

  250.     int duration;

  251.     int size= pkt->size;

  252. 

  253.     //XXX/FIXME use duration from pkt

  254.     if (st->codec->codec_type == CODEC_TYPE_AUDIO) {

  255.         duration = ((float)st->codec->frame_size / st->codec->sample_rate * 1000000.0);

  256.     } else {

  257.         duration = (1000000.0 * st->codec->time_base.num / (float)st->codec->time_base.den);

  258.     }

  259. 

  260.     pts = fst->pts;

  261.     /* packet size & key_frame */

  262.     header[0] = pkt->stream_index;

  263.     header[1] = 0;

  264.     if (pkt->flags & PKT_FLAG_KEY)

  265.         header[1] |= FLAG_KEY_FRAME;

  266.     header[2] = (size >> 16) & 0xff;

  267.     header[3] = (size >> 8) & 0xff;

  268.     header[4] = size & 0xff;

  269.     header[5] = (duration >> 16) & 0xff;

  270.     header[6] = (duration >> 8) & 0xff;

  271.     header[7] = duration & 0xff;

  272.     ffm_write_data(s, header, FRAME_HEADER_SIZE, pts, 1);

  273.     ffm_write_data(s, pkt->data, size, pts, 0);

  274. 

  275.     fst->pts += duration;

  276.     return 0;

  277. }

  278. 

  279. static int ffm_write_trailer(AVFormatContext *s)

  280. {

  281.     ByteIOContext *pb = &s->pb;

  282.     FFMContext *ffm = s->priv_data;

  283. 

  284.     /* flush packets */

  285.     if (ffm->packet_ptr > ffm->packet)

  286.         flush_packet(s);

  287. 

  288.     put_flush_packet(pb);

  289. 

  290.     if (!url_is_streamed(pb)) {

  291.         int64_t size;

  292.         /* update the write offset */

  293.         size = url_ftell(pb);

  294.         url_fseek(pb, 8, SEEK_SET);

  295.         put_be64(pb, size);

  296.         put_flush_packet(pb);

  297.     }

  298. 

  299.     return 0;

  300. }

  301. #endif //CONFIG_MUXERS

  302. 

  303. /* ffm demux */

  304. 

  305. static int ffm_is_avail_data(AVFormatContext *s, int size)

  306. {

  307.     FFMContext *ffm = s->priv_data;

  308.     offset_t pos, avail_size;

  309.     int len;

  310. 

  311.     len = ffm->packet_end - ffm->packet_ptr;

  312.     if (!ffm_nopts) {

  313.         /* XXX: I don't understand this test, so I disabled it for testing */

  314.         if (size <= len)

  315.             return 1;

  316.     }

  317.     pos = url_ftell(&s->pb);

  318.     if (pos == ffm->write_index) {

  319.         /* exactly at the end of stream */

  320.         return 0;

  321.     } else if (pos < ffm->write_index) {

  322.         avail_size = ffm->write_index - pos;

  323.     } else {

  324.         avail_size = (ffm->file_size - pos) + (ffm->write_index - FFM_PACKET_SIZE);

  325.     }

  326.     avail_size = (avail_size / ffm->packet_size) * (ffm->packet_size - FFM_HEADER_SIZE) + len;

  327.     if (size <= avail_size)

  328.         return 1;

  329.     else

  330.         return 0;

  331. }

  332. 

  333. /* first is true if we read the frame header */

  334. static int ffm_read_data(AVFormatContext *s,

  335.                          uint8_t *buf, int size, int first)

  336. {

  337.     FFMContext *ffm = s->priv_data;

  338.     ByteIOContext *pb = &s->pb;

  339.     int len, fill_size, size1, frame_offset;

  340. 

  341.     size1 = size;

  342.     while (size > 0) {

  343.     redo:

  344.         len = ffm->packet_end - ffm->packet_ptr;

  345.         if (len > size)

  346.             len = size;

  347.         if (len == 0) {

  348.             if (url_ftell(pb) == ffm->file_size)

  349.                 url_fseek(pb, ffm->packet_size, SEEK_SET);

  350.     retry_read:

  351.             get_be16(pb); /* PACKET_ID */

  352.             fill_size = get_be16(pb);

  353.             ffm->pts = get_be64(pb);

  354.             ffm->first_frame_in_packet = 1;

  355.             frame_offset = get_be16(pb);

  356.             get_buffer(pb, ffm->packet, ffm->packet_size - FFM_HEADER_SIZE);

  357.             ffm->packet_end = ffm->packet + (ffm->packet_size - FFM_HEADER_SIZE - fill_size);

  358.             if (ffm->packet_end < ffm->packet)

  359.                 return -1;

  360.             /* if first packet or resynchronization packet, we must

  361.                handle it specifically */

  362.             if (ffm->first_packet || (frame_offset & 0x8000)) {

  363.                 if (!frame_offset) {

  364.                     /* This packet has no frame headers in it */

  365.                     if (url_ftell(pb) >= ffm->packet_size * 3) {

  366.                         url_fseek(pb, -ffm->packet_size * 2, SEEK_CUR);

  367.                         goto retry_read;

  368.                     }

  369.                     /* This is bad, we cannot find a valid frame header */

  370.                     return 0;

  371.                 }

  372.                 ffm->first_packet = 0;

  373.                 if ((frame_offset & 0x7ffff) < FFM_HEADER_SIZE)

  374.                     return -1;

  375.                 ffm->packet_ptr = ffm->packet + (frame_offset & 0x7fff) - FFM_HEADER_SIZE;

  376.                 if (!first)

  377.                     break;

  378.             } else {

  379.                 ffm->packet_ptr = ffm->packet;

  380.             }

  381.             goto redo;

  382.         }

  383.         memcpy(buf, ffm->packet_ptr, len);

  384.         buf += len;

  385.         ffm->packet_ptr += len;

  386.         size -= len;

  387.         first = 0;

  388.     }

  389.     return size1 - size;

  390. }

  391. 

  392. 

  393. static void adjust_write_index(AVFormatContext *s)

  394. {

  395.     FFMContext *ffm = s->priv_data;

  396.     ByteIOContext *pb = &s->pb;

  397.     int64_t pts;

  398.     //offset_t orig_write_index = ffm->write_index;

  399.     offset_t pos_min, pos_max;

  400.     int64_t pts_start;

  401.     offset_t ptr = url_ftell(pb);

  402. 

  403. 

  404.     pos_min = 0;

  405.     pos_max = ffm->file_size - 2 * FFM_PACKET_SIZE;

  406. 

  407.     pts_start = get_pts(s, pos_min);

  408. 

  409.     pts = get_pts(s, pos_max);

  410. 

  411.     if (pts - 100000 > pts_start)

  412.         goto end;

  413. 

  414.     ffm->write_index = FFM_PACKET_SIZE;

  415. 

  416.     pts_start = get_pts(s, pos_min);

  417. 

  418.     pts = get_pts(s, pos_max);

  419. 

  420.     if (pts - 100000 <= pts_start) {

  421.         while (1) {

  422.             offset_t newpos;

  423.             int64_t newpts;

  424. 

  425.             newpos = ((pos_max + pos_min) / (2 * FFM_PACKET_SIZE)) * FFM_PACKET_SIZE;

  426. 

  427.             if (newpos == pos_min)

  428.                 break;

  429. 

  430.             newpts = get_pts(s, newpos);

  431. 

  432.             if (newpts - 100000 <= pts) {

  433.                 pos_max = newpos;

  434.                 pts = newpts;

  435.             } else {

  436.                 pos_min = newpos;

  437.             }

  438.         }

  439.         ffm->write_index += pos_max;

  440.     }

  441. 

  442.     //printf("Adjusted write index from %"PRId64" to %"PRId64": pts=%0.6f\n", orig_write_index, ffm->write_index, pts / 1000000.);

  443.     //printf("pts range %0.6f - %0.6f\n", get_pts(s, 0) / 1000000. , get_pts(s, ffm->file_size - 2 * FFM_PACKET_SIZE) / 1000000. );

  444. 

  445.  end:

  446.     url_fseek(pb, ptr, SEEK_SET);

  447. }

  448. 

  449. 

  450. static int ffm_read_header(AVFormatContext *s, AVFormatParameters *ap)

  451. {

  452.     FFMContext *ffm = s->priv_data;

  453.     AVStream *st;

  454.     FFMStream *fst;

  455.     ByteIOContext *pb = &s->pb;

  456.     AVCodecContext *codec;

  457.     int i, nb_streams;

  458.     uint32_t tag;

  459. 

  460.     /* header */

  461.     tag = get_le32(pb);

  462.     if (tag != MKTAG('F', 'F', 'M', '1'))

  463.         goto fail;

  464.     ffm->packet_size = get_be32(pb);

  465.     if (ffm->packet_size != FFM_PACKET_SIZE)

  466.         goto fail;

  467.     ffm->write_index = get_be64(pb);

  468.     /* get also filesize */

  469.     if (!url_is_streamed(pb)) {

  470.         ffm->file_size = url_fsize(pb);

  471.         adjust_write_index(s);

  472.     } else {

  473.         ffm->file_size = (UINT64_C(1) << 63) - 1;

  474.     }

  475. 

  476.     nb_streams = get_be32(pb);

  477.     get_be32(pb); /* total bitrate */

  478.     /* read each stream */

  479.     for(i=0;i<nb_streams;i++) {

  480.         char rc_eq_buf[128];

  481. 

  482.         st = av_new_stream(s, 0);

  483.         if (!st)

  484.             goto fail;

  485.         fst = av_mallocz(sizeof(FFMStream));

  486.         if (!fst)

  487.             goto fail;

  488.         s->streams[i] = st;

  489. 

  490.         av_set_pts_info(st, 64, 1, 1000000);

  491. 

  492.         st->priv_data = fst;

  493. 

  494.         codec = st->codec;

  495.         /* generic info */

  496.         codec->codec_id = get_be32(pb);

  497.         codec->codec_type = get_byte(pb); /* codec_type */

  498.         codec->bit_rate = get_be32(pb);

  499.         st->quality = get_be32(pb);

  500.         codec->flags = get_be32(pb);

  501.         codec->flags2 = get_be32(pb);

  502.         codec->debug = get_be32(pb);

  503.         /* specific info */

  504.         switch(codec->codec_type) {

  505.         case CODEC_TYPE_VIDEO:

  506.             codec->time_base.num = get_be32(pb);

  507.             codec->time_base.den = get_be32(pb);

  508.             codec->width = get_be16(pb);

  509.             codec->height = get_be16(pb);

  510.             codec->gop_size = get_be16(pb);

  511.             codec->pix_fmt = get_be32(pb);

  512.             codec->qmin = get_byte(pb);

  513.             codec->qmax = get_byte(pb);

  514.             codec->max_qdiff = get_byte(pb);

  515.             codec->qcompress = get_be16(pb) / 10000.0;

  516.             codec->qblur = get_be16(pb) / 10000.0;

  517.             codec->bit_rate_tolerance = get_be32(pb);

  518.             codec->rc_eq = av_strdup(get_strz(pb, rc_eq_buf, sizeof(rc_eq_buf)));

  519.             codec->rc_max_rate = get_be32(pb);

  520.             codec->rc_min_rate = get_be32(pb);

  521.             codec->rc_buffer_size = get_be32(pb);

  522.             codec->i_quant_factor = av_int2dbl(get_be64(pb));

  523.             codec->b_quant_factor = av_int2dbl(get_be64(pb));

  524.             codec->i_quant_offset = av_int2dbl(get_be64(pb));

  525.             codec->b_quant_offset = av_int2dbl(get_be64(pb));

  526.             codec->dct_algo = get_be32(pb);

  527.             codec->strict_std_compliance = get_be32(pb);

  528.             codec->max_b_frames = get_be32(pb);

  529.             codec->luma_elim_threshold = get_be32(pb);

  530.             codec->chroma_elim_threshold = get_be32(pb);

  531.             codec->mpeg_quant = get_be32(pb);

  532.             codec->intra_dc_precision = get_be32(pb);

  533.             codec->me_method = get_be32(pb);

  534.             codec->mb_decision = get_be32(pb);

  535.             codec->nsse_weight = get_be32(pb);

  536.             codec->frame_skip_cmp = get_be32(pb);

  537.             codec->rc_buffer_aggressivity = av_int2dbl(get_be64(pb));

  538.             codec->codec_tag = get_be32(pb);

  539.             break;

  540.         case CODEC_TYPE_AUDIO:

  541.             codec->sample_rate = get_be32(pb);

  542.             codec->channels = get_le16(pb);

  543.             codec->frame_size = get_le16(pb);

  544.             break;

  545.         default:

  546.             goto fail;

  547.         }

  548. 

  549.     }

  550. 

  551.     /* get until end of block reached */

  552.     while ((url_ftell(pb) % ffm->packet_size) != 0)

  553.         get_byte(pb);

  554. 

  555.     /* init packet demux */

  556.     ffm->packet_ptr = ffm->packet;

  557.     ffm->packet_end = ffm->packet;

  558.     ffm->frame_offset = 0;

  559.     ffm->pts = 0;

  560.     ffm->read_state = READ_HEADER;

  561.     ffm->first_packet = 1;

  562.     return 0;

  563.  fail:

  564.     for(i=0;i<s->nb_streams;i++) {

  565.         st = s->streams[i];

  566.         if (st) {

  567.             av_freep(&st->priv_data);

  568.             av_free(st);

  569.         }

  570.     }

  571.     return -1;

  572. }

  573. 

  574. /* return < 0 if eof */

  575. static int ffm_read_packet(AVFormatContext *s, AVPacket *pkt)

  576. {

  577.     int size;

  578.     FFMContext *ffm = s->priv_data;

  579.     int duration;

  580. 

  581.     switch(ffm->read_state) {

  582.     case READ_HEADER:

  583.         if (!ffm_is_avail_data(s, FRAME_HEADER_SIZE)) {

  584.             return AVERROR(EAGAIN);

  585.         }

  586. #if 0

  587.         printf("pos=%08"PRIx64" spos=%"PRIx64", write_index=%"PRIx64" size=%"PRIx64"\n",

  588.                url_ftell(&s->pb), s->pb.pos, ffm->write_index, ffm->file_size);

  589. #endif

  590.         if (ffm_read_data(s, ffm->header, FRAME_HEADER_SIZE, 1) !=

  591.             FRAME_HEADER_SIZE)

  592.             return AVERROR(EAGAIN);

  593. #if 0

  594.         {

  595.             int i;

  596.             for(i=0;i<FRAME_HEADER_SIZE;i++)

  597.                 printf("%02x ", ffm->header[i]);

  598.             printf("\n");

  599.         }

  600. #endif

  601.         ffm->read_state = READ_DATA;

  602.         /* fall thru */

  603.     case READ_DATA:

  604.         size = (ffm->header[2] << 16) | (ffm->header[3] << 8) | ffm->header[4];

  605.         if (!ffm_is_avail_data(s, size)) {

  606.             return AVERROR(EAGAIN);

  607.         }

  608. 

  609.         duration = (ffm->header[5] << 16) | (ffm->header[6] << 8) | ffm->header[7];

  610. 

  611.         av_new_packet(pkt, size);

  612.         pkt->stream_index = ffm->header[0];

  613.         pkt->pos = url_ftell(&s->pb);

  614.         if (ffm->header[1] & FLAG_KEY_FRAME)

  615.             pkt->flags |= PKT_FLAG_KEY;

  616. 

  617.         ffm->read_state = READ_HEADER;

  618.         if (ffm_read_data(s, pkt->data, size, 0) != size) {

  619.             /* bad case: desynchronized packet. we cancel all the packet loading */

  620.             av_free_packet(pkt);

  621.             return AVERROR(EAGAIN);

  622.         }

  623.         if (ffm->first_frame_in_packet)

  624.         {

  625.             pkt->pts = ffm->pts;

  626.             ffm->first_frame_in_packet = 0;

  627.         }

  628.         pkt->duration = duration;

  629.         break;

  630.     }

  631.     return 0;

  632. }

  633. 

  634. //#define DEBUG_SEEK

  635. 

  636. /* pos is between 0 and file_size - FFM_PACKET_SIZE. It is translated

  637.    by the write position inside this function */

  638. static void ffm_seek1(AVFormatContext *s, offset_t pos1)

  639. {

  640.     FFMContext *ffm = s->priv_data;

  641.     ByteIOContext *pb = &s->pb;

  642.     offset_t pos;

  643. 

  644.     pos = pos1 + ffm->write_index;

  645.     if (pos >= ffm->file_size)

  646.         pos -= (ffm->file_size - FFM_PACKET_SIZE);

  647. #ifdef DEBUG_SEEK

  648.     printf("seek to %"PRIx64" -> %"PRIx64"\n", pos1, pos);

  649. #endif

  650.     url_fseek(pb, pos, SEEK_SET);

  651. }

  652. 

  653. static int64_t get_pts(AVFormatContext *s, offset_t pos)

  654. {

  655.     ByteIOContext *pb = &s->pb;

  656.     int64_t pts;

  657. 

  658.     ffm_seek1(s, pos);

  659.     url_fskip(pb, 4);

  660.     pts = get_be64(pb);

  661. #ifdef DEBUG_SEEK

  662.     printf("pts=%0.6f\n", pts / 1000000.0);

  663. #endif

  664.     return pts;

  665. }

  666. 

  667. /* seek to a given time in the file. The file read pointer is

  668.    positionned at or before pts. XXX: the following code is quite

  669.    approximative */

  670. static int ffm_seek(AVFormatContext *s, int stream_index, int64_t wanted_pts, int flags)

  671. {

  672.     FFMContext *ffm = s->priv_data;

  673.     offset_t pos_min, pos_max, pos;

  674.     int64_t pts_min, pts_max, pts;

  675.     double pos1;

  676. 

  677. #ifdef DEBUG_SEEK

  678.     printf("wanted_pts=%0.6f\n", wanted_pts / 1000000.0);

  679. #endif

  680.     /* find the position using linear interpolation (better than

  681.        dichotomy in typical cases) */

  682.     pos_min = 0;

  683.     pos_max = ffm->file_size - 2 * FFM_PACKET_SIZE;

  684.     while (pos_min <= pos_max) {

  685.         pts_min = get_pts(s, pos_min);

  686.         pts_max = get_pts(s, pos_max);

  687.         /* linear interpolation */

  688.         pos1 = (double)(pos_max - pos_min) * (double)(wanted_pts - pts_min) /

  689.             (double)(pts_max - pts_min);

  690.         pos = (((int64_t)pos1) / FFM_PACKET_SIZE) * FFM_PACKET_SIZE;

  691.         if (pos <= pos_min)

  692.             pos = pos_min;

  693.         else if (pos >= pos_max)

  694.             pos = pos_max;

  695.         pts = get_pts(s, pos);

  696.         /* check if we are lucky */

  697.         if (pts == wanted_pts) {

  698.             goto found;

  699.         } else if (pts > wanted_pts) {

  700.             pos_max = pos - FFM_PACKET_SIZE;

  701.         } else {

  702.             pos_min = pos + FFM_PACKET_SIZE;

  703.         }

  704.     }

  705.     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;

  706.     if (pos > 0)

  707.         pos -= FFM_PACKET_SIZE;

  708.  found:

  709.     ffm_seek1(s, pos);

  710.     return 0;

  711. }

  712. 

  713. #ifdef CONFIG_FFSERVER

  714. offset_t ffm_read_write_index(int fd)

  715. {

  716.     uint8_t buf[8];

  717.     offset_t pos;

  718.     int i;

  719. 

  720.     lseek(fd, 8, SEEK_SET);

  721.     read(fd, buf, 8);

  722.     pos = 0;

  723.     for(i=0;i<8;i++)

  724.         pos |= (int64_t)buf[i] << (56 - i * 8);

  725.     return pos;

  726. }

  727. 

  728. void ffm_write_write_index(int fd, offset_t pos)

  729. {

  730.     uint8_t buf[8];

  731.     int i;

  732. 

  733.     for(i=0;i<8;i++)

  734.         buf[i] = (pos >> (56 - i * 8)) & 0xff;

  735.     lseek(fd, 8, SEEK_SET);

  736.     write(fd, buf, 8);

  737. }

  738. 

  739. void ffm_set_write_index(AVFormatContext *s, offset_t pos, offset_t file_size)

  740. {

  741.     FFMContext *ffm = s->priv_data;

  742.     ffm->write_index = pos;

  743.     ffm->file_size = file_size;

  744. }

  745. #endif // CONFIG_FFSERVER

  746. 

  747. static int ffm_read_close(AVFormatContext *s)

  748. {

  749.     AVStream *st;

  750.     int i;

  751. 

  752.     for(i=0;i<s->nb_streams;i++) {

  753.         st = s->streams[i];

  754.         av_freep(&st->priv_data);

  755.     }

  756.     return 0;

  757. }

  758. 

  759. static int ffm_probe(AVProbeData *p)

  760. {

  761.     if (p->buf_size >= 4 &&

  762.         p->buf[0] == 'F' && p->buf[1] == 'F' && p->buf[2] == 'M' &&

  763.         p->buf[3] == '1')

  764.         return AVPROBE_SCORE_MAX + 1;

  765.     return 0;

  766. }

  767. 

  768. #ifdef CONFIG_FFM_DEMUXER

  769. AVInputFormat ffm_demuxer = {

  770.     "ffm",

  771.     "ffm format",

  772.     sizeof(FFMContext),

  773.     ffm_probe,

  774.     ffm_read_header,

  775.     ffm_read_packet,

  776.     ffm_read_close,

  777.     ffm_seek,

  778. };

  779. #endif

  780. #ifdef CONFIG_FFM_MUXER

  781. AVOutputFormat ffm_muxer = {

  782.     "ffm",

  783.     "ffm format",

  784.     "",

  785.     "ffm",

  786.     sizeof(FFMContext),

  787.     /* not really used */

  788.     CODEC_ID_MP2,

  789.     CODEC_ID_MPEG1VIDEO,

  790.     ffm_write_header,

  791.     ffm_write_packet,

  792.     ffm_write_trailer,

  793. };

  794. #endif //CONFIG_FFM_MUXER