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

648 lines
21KB
Raw Blame History 

  1. /*

  2.  * Interplay MVE File Demuxer

  3.  * Copyright (c) 2003 The ffmpeg Project

  4.  *

  5.  * This file is part of Libav.

  6.  *

  7.  * Libav 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.  * Libav 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 Libav; if not, write to the Free Software

  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  20.  */

  21. 

  22. /**

  23.  * @file

  24.  * Interplay MVE file demuxer

  25.  * by Mike Melanson (melanson@pcisys.net)

  26.  * For more information regarding the Interplay MVE file format, visit:

  27.  *   http://www.pcisys.net/~melanson/codecs/

  28.  * The aforementioned site also contains a command line utility for parsing

  29.  * IP MVE files so that you can get a good idea of the typical structure of

  30.  * such files. This demuxer is not the best example to use if you are trying

  31.  * to write your own as it uses a rather roundabout approach for splitting

  32.  * up and sending out the chunks.

  33.  */

  34. 

  35. #include "libavutil/channel_layout.h"

  36. #include "libavutil/intreadwrite.h"

  37. #include "avformat.h"

  38. #include "internal.h"

  39. 

  40. #define CHUNK_PREAMBLE_SIZE 4

  41. #define OPCODE_PREAMBLE_SIZE 4

  42. 

  43. #define CHUNK_INIT_AUDIO   0x0000

  44. #define CHUNK_AUDIO_ONLY   0x0001

  45. #define CHUNK_INIT_VIDEO   0x0002

  46. #define CHUNK_VIDEO        0x0003

  47. #define CHUNK_SHUTDOWN     0x0004

  48. #define CHUNK_END          0x0005

  49. /* these last types are used internally */

  50. #define CHUNK_DONE         0xFFFC

  51. #define CHUNK_NOMEM        0xFFFD

  52. #define CHUNK_EOF          0xFFFE

  53. #define CHUNK_BAD          0xFFFF

  54. 

  55. #define OPCODE_END_OF_STREAM           0x00

  56. #define OPCODE_END_OF_CHUNK            0x01

  57. #define OPCODE_CREATE_TIMER            0x02

  58. #define OPCODE_INIT_AUDIO_BUFFERS      0x03

  59. #define OPCODE_START_STOP_AUDIO        0x04

  60. #define OPCODE_INIT_VIDEO_BUFFERS      0x05

  61. #define OPCODE_UNKNOWN_06              0x06

  62. #define OPCODE_SEND_BUFFER             0x07

  63. #define OPCODE_AUDIO_FRAME             0x08

  64. #define OPCODE_SILENCE_FRAME           0x09

  65. #define OPCODE_INIT_VIDEO_MODE         0x0A

  66. #define OPCODE_CREATE_GRADIENT         0x0B

  67. #define OPCODE_SET_PALETTE             0x0C

  68. #define OPCODE_SET_PALETTE_COMPRESSED  0x0D

  69. #define OPCODE_UNKNOWN_0E              0x0E

  70. #define OPCODE_SET_DECODING_MAP        0x0F

  71. #define OPCODE_UNKNOWN_10              0x10

  72. #define OPCODE_VIDEO_DATA              0x11

  73. #define OPCODE_UNKNOWN_12              0x12

  74. #define OPCODE_UNKNOWN_13              0x13

  75. #define OPCODE_UNKNOWN_14              0x14

  76. #define OPCODE_UNKNOWN_15              0x15

  77. 

  78. #define PALETTE_COUNT 256

  79. 

  80. typedef struct IPMVEContext {

  81. 

  82.     unsigned char *buf;

  83.     int buf_size;

  84. 

  85.     uint64_t frame_pts_inc;

  86. 

  87.     unsigned int video_bpp;

  88.     unsigned int video_width;

  89.     unsigned int video_height;

  90.     int64_t video_pts;

  91.     uint32_t     palette[256];

  92.     int          has_palette;

  93.     int          changed;

  94. 

  95.     unsigned int audio_bits;

  96.     unsigned int audio_channels;

  97.     unsigned int audio_sample_rate;

  98.     enum AVCodecID audio_type;

  99.     unsigned int audio_frame_count;

  100. 

  101.     int video_stream_index;

  102.     int audio_stream_index;

  103. 

  104.     int64_t audio_chunk_offset;

  105.     int audio_chunk_size;

  106.     int64_t video_chunk_offset;

  107.     int video_chunk_size;

  108.     int64_t decode_map_chunk_offset;

  109.     int decode_map_chunk_size;

  110. 

  111.     int64_t next_chunk_offset;

  112. 

  113. } IPMVEContext;

  114. 

  115. static int load_ipmovie_packet(IPMVEContext *s, AVIOContext *pb,

  116.     AVPacket *pkt) {

  117. 

  118.     int chunk_type;

  119. 

  120.     if (s->audio_chunk_offset) {

  121.         if (s->audio_type == AV_CODEC_ID_NONE) {

  122.             av_log(NULL, AV_LOG_ERROR, "Can not read audio packet before"

  123.                    "audio codec is known\n");

  124.                 return CHUNK_BAD;

  125.         }

  126. 

  127.         /* adjust for PCM audio by skipping chunk header */

  128.         if (s->audio_type != AV_CODEC_ID_INTERPLAY_DPCM) {

  129.             s->audio_chunk_offset += 6;

  130.             s->audio_chunk_size -= 6;

  131.         }

  132. 

  133.         avio_seek(pb, s->audio_chunk_offset, SEEK_SET);

  134.         s->audio_chunk_offset = 0;

  135. 

  136.         if (s->audio_chunk_size != av_get_packet(pb, pkt, s->audio_chunk_size))

  137.             return CHUNK_EOF;

  138. 

  139.         pkt->stream_index = s->audio_stream_index;

  140.         pkt->pts = s->audio_frame_count;

  141. 

  142.         /* audio frame maintenance */

  143.         if (s->audio_type != AV_CODEC_ID_INTERPLAY_DPCM)

  144.             s->audio_frame_count +=

  145.             (s->audio_chunk_size / s->audio_channels / (s->audio_bits / 8));

  146.         else

  147.             s->audio_frame_count +=

  148.                 (s->audio_chunk_size - 6 - s->audio_channels) / s->audio_channels;

  149. 

  150.         av_dlog(NULL, "sending audio frame with pts %"PRId64" (%d audio frames)\n",

  151.                 pkt->pts, s->audio_frame_count);

  152. 

  153.         chunk_type = CHUNK_VIDEO;

  154. 

  155.     } else if (s->decode_map_chunk_offset) {

  156. 

  157.         /* send both the decode map and the video data together */

  158. 

  159.         if (av_new_packet(pkt, s->decode_map_chunk_size + s->video_chunk_size))

  160.             return CHUNK_NOMEM;

  161. 

  162.         if (s->has_palette) {

  163.             uint8_t *pal;

  164. 

  165.             pal = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE,

  166.                                           AVPALETTE_SIZE);

  167.             if (pal) {

  168.                 memcpy(pal, s->palette, AVPALETTE_SIZE);

  169.                 s->has_palette = 0;

  170.             }

  171.         }

  172. 

  173.         if (s->changed) {

  174.             ff_add_param_change(pkt, 0, 0, 0, s->video_width, s->video_height);

  175.             s->changed = 0;

  176.         }

  177.         pkt->pos= s->decode_map_chunk_offset;

  178.         avio_seek(pb, s->decode_map_chunk_offset, SEEK_SET);

  179.         s->decode_map_chunk_offset = 0;

  180. 

  181.         if (avio_read(pb, pkt->data, s->decode_map_chunk_size) !=

  182.             s->decode_map_chunk_size) {

  183.             av_free_packet(pkt);

  184.             return CHUNK_EOF;

  185.         }

  186. 

  187.         avio_seek(pb, s->video_chunk_offset, SEEK_SET);

  188.         s->video_chunk_offset = 0;

  189. 

  190.         if (avio_read(pb, pkt->data + s->decode_map_chunk_size,

  191.             s->video_chunk_size) != s->video_chunk_size) {

  192.             av_free_packet(pkt);

  193.             return CHUNK_EOF;

  194.         }

  195. 

  196.         pkt->stream_index = s->video_stream_index;

  197.         pkt->pts = s->video_pts;

  198. 

  199.         av_dlog(NULL, "sending video frame with pts %"PRId64"\n", pkt->pts);

  200. 

  201.         s->video_pts += s->frame_pts_inc;

  202. 

  203.         chunk_type = CHUNK_VIDEO;

  204. 

  205.     } else {

  206. 

  207.         avio_seek(pb, s->next_chunk_offset, SEEK_SET);

  208.         chunk_type = CHUNK_DONE;

  209. 

  210.     }

  211. 

  212.     return chunk_type;

  213. }

  214. 

  215. /* This function loads and processes a single chunk in an IP movie file.

  216.  * It returns the type of chunk that was processed. */

  217. static int process_ipmovie_chunk(IPMVEContext *s, AVIOContext *pb,

  218.     AVPacket *pkt)

  219. {

  220.     unsigned char chunk_preamble[CHUNK_PREAMBLE_SIZE];

  221.     int chunk_type;

  222.     int chunk_size;

  223.     unsigned char opcode_preamble[OPCODE_PREAMBLE_SIZE];

  224.     unsigned char opcode_type;

  225.     unsigned char opcode_version;

  226.     int opcode_size;

  227.     unsigned char scratch[1024];

  228.     int i, j;

  229.     int first_color, last_color;

  230.     int audio_flags;

  231.     unsigned char r, g, b;

  232.     unsigned int width, height;

  233. 

  234.     /* see if there are any pending packets */

  235.     chunk_type = load_ipmovie_packet(s, pb, pkt);

  236.     if (chunk_type != CHUNK_DONE)

  237.         return chunk_type;

  238. 

  239.     /* read the next chunk, wherever the file happens to be pointing */

  240.     if (pb->eof_reached)

  241.         return CHUNK_EOF;

  242.     if (avio_read(pb, chunk_preamble, CHUNK_PREAMBLE_SIZE) !=

  243.         CHUNK_PREAMBLE_SIZE)

  244.         return CHUNK_BAD;

  245.     chunk_size = AV_RL16(&chunk_preamble[0]);

  246.     chunk_type = AV_RL16(&chunk_preamble[2]);

  247. 

  248.     av_dlog(NULL, "chunk type 0x%04X, 0x%04X bytes: ", chunk_type, chunk_size);

  249. 

  250.     switch (chunk_type) {

  251. 

  252.     case CHUNK_INIT_AUDIO:

  253.         av_dlog(NULL, "initialize audio\n");

  254.         break;

  255. 

  256.     case CHUNK_AUDIO_ONLY:

  257.         av_dlog(NULL, "audio only\n");

  258.         break;

  259. 

  260.     case CHUNK_INIT_VIDEO:

  261.         av_dlog(NULL, "initialize video\n");

  262.         break;

  263. 

  264.     case CHUNK_VIDEO:

  265.         av_dlog(NULL, "video (and audio)\n");

  266.         break;

  267. 

  268.     case CHUNK_SHUTDOWN:

  269.         av_dlog(NULL, "shutdown\n");

  270.         break;

  271. 

  272.     case CHUNK_END:

  273.         av_dlog(NULL, "end\n");

  274.         break;

  275. 

  276.     default:

  277.         av_dlog(NULL, "invalid chunk\n");

  278.         chunk_type = CHUNK_BAD;

  279.         break;

  280. 

  281.     }

  282. 

  283.     while ((chunk_size > 0) && (chunk_type != CHUNK_BAD)) {

  284. 

  285.         /* read the next chunk, wherever the file happens to be pointing */

  286.         if (pb->eof_reached) {

  287.             chunk_type = CHUNK_EOF;

  288.             break;

  289.         }

  290.         if (avio_read(pb, opcode_preamble, CHUNK_PREAMBLE_SIZE) !=

  291.             CHUNK_PREAMBLE_SIZE) {

  292.             chunk_type = CHUNK_BAD;

  293.             break;

  294.         }

  295. 

  296.         opcode_size = AV_RL16(&opcode_preamble[0]);

  297.         opcode_type = opcode_preamble[2];

  298.         opcode_version = opcode_preamble[3];

  299. 

  300.         chunk_size -= OPCODE_PREAMBLE_SIZE;

  301.         chunk_size -= opcode_size;

  302.         if (chunk_size < 0) {

  303.             av_dlog(NULL, "chunk_size countdown just went negative\n");

  304.             chunk_type = CHUNK_BAD;

  305.             break;

  306.         }

  307. 

  308.         av_dlog(NULL, "  opcode type %02X, version %d, 0x%04X bytes: ",

  309.                 opcode_type, opcode_version, opcode_size);

  310.         switch (opcode_type) {

  311. 

  312.         case OPCODE_END_OF_STREAM:

  313.             av_dlog(NULL, "end of stream\n");

  314.             avio_skip(pb, opcode_size);

  315.             break;

  316. 

  317.         case OPCODE_END_OF_CHUNK:

  318.             av_dlog(NULL, "end of chunk\n");

  319.             avio_skip(pb, opcode_size);

  320.             break;

  321. 

  322.         case OPCODE_CREATE_TIMER:

  323.             av_dlog(NULL, "create timer\n");

  324.             if ((opcode_version > 0) || (opcode_size > 6)) {

  325.                 av_dlog(NULL, "bad create_timer opcode\n");

  326.                 chunk_type = CHUNK_BAD;

  327.                 break;

  328.             }

  329.             if (avio_read(pb, scratch, opcode_size) !=

  330.                 opcode_size) {

  331.                 chunk_type = CHUNK_BAD;

  332.                 break;

  333.             }

  334.             s->frame_pts_inc = ((uint64_t)AV_RL32(&scratch[0])) * AV_RL16(&scratch[4]);

  335.             av_dlog(NULL, "  %.2f frames/second (timer div = %d, subdiv = %d)\n",

  336.                     1000000.0 / s->frame_pts_inc, AV_RL32(&scratch[0]),

  337.                     AV_RL16(&scratch[4]));

  338.             break;

  339. 

  340.         case OPCODE_INIT_AUDIO_BUFFERS:

  341.             av_dlog(NULL, "initialize audio buffers\n");

  342.             if ((opcode_version > 1) || (opcode_size > 10)) {

  343.                 av_dlog(NULL, "bad init_audio_buffers opcode\n");

  344.                 chunk_type = CHUNK_BAD;

  345.                 break;

  346.             }

  347.             if (avio_read(pb, scratch, opcode_size) !=

  348.                 opcode_size) {

  349.                 chunk_type = CHUNK_BAD;

  350.                 break;

  351.             }

  352.             s->audio_sample_rate = AV_RL16(&scratch[4]);

  353.             audio_flags = AV_RL16(&scratch[2]);

  354.             /* bit 0 of the flags: 0 = mono, 1 = stereo */

  355.             s->audio_channels = (audio_flags & 1) + 1;

  356.             /* bit 1 of the flags: 0 = 8 bit, 1 = 16 bit */

  357.             s->audio_bits = (((audio_flags >> 1) & 1) + 1) * 8;

  358.             /* bit 2 indicates compressed audio in version 1 opcode */

  359.             if ((opcode_version == 1) && (audio_flags & 0x4))

  360.                 s->audio_type = AV_CODEC_ID_INTERPLAY_DPCM;

  361.             else if (s->audio_bits == 16)

  362.                 s->audio_type = AV_CODEC_ID_PCM_S16LE;

  363.             else

  364.                 s->audio_type = AV_CODEC_ID_PCM_U8;

  365.             av_dlog(NULL, "audio: %d bits, %d Hz, %s, %s format\n",

  366.                     s->audio_bits, s->audio_sample_rate,

  367.                     (s->audio_channels == 2) ? "stereo" : "mono",

  368.                     (s->audio_type == AV_CODEC_ID_INTERPLAY_DPCM) ?

  369.                     "Interplay audio" : "PCM");

  370.             break;

  371. 

  372.         case OPCODE_START_STOP_AUDIO:

  373.             av_dlog(NULL, "start/stop audio\n");

  374.             avio_skip(pb, opcode_size);

  375.             break;

  376. 

  377.         case OPCODE_INIT_VIDEO_BUFFERS:

  378.             av_dlog(NULL, "initialize video buffers\n");

  379.             if ((opcode_version > 2) || (opcode_size > 8)) {

  380.                 av_dlog(NULL, "bad init_video_buffers opcode\n");

  381.                 chunk_type = CHUNK_BAD;

  382.                 break;

  383.             }

  384.             if (avio_read(pb, scratch, opcode_size) !=

  385.                 opcode_size) {

  386.                 chunk_type = CHUNK_BAD;

  387.                 break;

  388.             }

  389.             width  = AV_RL16(&scratch[0]) * 8;

  390.             height = AV_RL16(&scratch[2]) * 8;

  391.             if (width != s->video_width) {

  392.                 s->video_width = width;

  393.                 s->changed++;

  394.             }

  395.             if (height != s->video_height) {

  396.                 s->video_height = height;

  397.                 s->changed++;

  398.             }

  399.             if (opcode_version < 2 || !AV_RL16(&scratch[6])) {

  400.                 s->video_bpp = 8;

  401.             } else {

  402.                 s->video_bpp = 16;

  403.             }

  404.             av_dlog(NULL, "video resolution: %d x %d\n",

  405.                     s->video_width, s->video_height);

  406.             break;

  407. 

  408.         case OPCODE_UNKNOWN_06:

  409.         case OPCODE_UNKNOWN_0E:

  410.         case OPCODE_UNKNOWN_10:

  411.         case OPCODE_UNKNOWN_12:

  412.         case OPCODE_UNKNOWN_13:

  413.         case OPCODE_UNKNOWN_14:

  414.         case OPCODE_UNKNOWN_15:

  415.             av_dlog(NULL, "unknown (but documented) opcode %02X\n", opcode_type);

  416.             avio_skip(pb, opcode_size);

  417.             break;

  418. 

  419.         case OPCODE_SEND_BUFFER:

  420.             av_dlog(NULL, "send buffer\n");

  421.             avio_skip(pb, opcode_size);

  422.             break;

  423. 

  424.         case OPCODE_AUDIO_FRAME:

  425.             av_dlog(NULL, "audio frame\n");

  426. 

  427.             /* log position and move on for now */

  428.             s->audio_chunk_offset = avio_tell(pb);

  429.             s->audio_chunk_size = opcode_size;

  430.             avio_skip(pb, opcode_size);

  431.             break;

  432. 

  433.         case OPCODE_SILENCE_FRAME:

  434.             av_dlog(NULL, "silence frame\n");

  435.             avio_skip(pb, opcode_size);

  436.             break;

  437. 

  438.         case OPCODE_INIT_VIDEO_MODE:

  439.             av_dlog(NULL, "initialize video mode\n");

  440.             avio_skip(pb, opcode_size);

  441.             break;

  442. 

  443.         case OPCODE_CREATE_GRADIENT:

  444.             av_dlog(NULL, "create gradient\n");

  445.             avio_skip(pb, opcode_size);

  446.             break;

  447. 

  448.         case OPCODE_SET_PALETTE:

  449.             av_dlog(NULL, "set palette\n");

  450.             /* check for the logical maximum palette size

  451.              * (3 * 256 + 4 bytes) */

  452.             if (opcode_size > 0x304) {

  453.                 av_dlog(NULL, "demux_ipmovie: set_palette opcode too large\n");

  454.                 chunk_type = CHUNK_BAD;

  455.                 break;

  456.             }

  457.             if (avio_read(pb, scratch, opcode_size) != opcode_size) {

  458.                 chunk_type = CHUNK_BAD;

  459.                 break;

  460.             }

  461. 

  462.             /* load the palette into internal data structure */

  463.             first_color = AV_RL16(&scratch[0]);

  464.             last_color = first_color + AV_RL16(&scratch[2]) - 1;

  465.             /* sanity check (since they are 16 bit values) */

  466.             if ((first_color > 0xFF) || (last_color > 0xFF)) {

  467.                 av_dlog(NULL, "demux_ipmovie: set_palette indexes out of range (%d -> %d)\n",

  468.                     first_color, last_color);

  469.                 chunk_type = CHUNK_BAD;

  470.                 break;

  471.             }

  472.             j = 4;  /* offset of first palette data */

  473.             for (i = first_color; i <= last_color; i++) {

  474.                 /* the palette is stored as a 6-bit VGA palette, thus each

  475.                  * component is shifted up to a 8-bit range */

  476.                 r = scratch[j++] * 4;

  477.                 g = scratch[j++] * 4;

  478.                 b = scratch[j++] * 4;

  479.                 s->palette[i] = (r << 16) | (g << 8) | (b);

  480.             }

  481.             s->has_palette = 1;

  482.             break;

  483. 

  484.         case OPCODE_SET_PALETTE_COMPRESSED:

  485.             av_dlog(NULL, "set palette compressed\n");

  486.             avio_skip(pb, opcode_size);

  487.             break;

  488. 

  489.         case OPCODE_SET_DECODING_MAP:

  490.             av_dlog(NULL, "set decoding map\n");

  491. 

  492.             /* log position and move on for now */

  493.             s->decode_map_chunk_offset = avio_tell(pb);

  494.             s->decode_map_chunk_size = opcode_size;

  495.             avio_skip(pb, opcode_size);

  496.             break;

  497. 

  498.         case OPCODE_VIDEO_DATA:

  499.             av_dlog(NULL, "set video data\n");

  500. 

  501.             /* log position and move on for now */

  502.             s->video_chunk_offset = avio_tell(pb);

  503.             s->video_chunk_size = opcode_size;

  504.             avio_skip(pb, opcode_size);

  505.             break;

  506. 

  507.         default:

  508.             av_dlog(NULL, "*** unknown opcode type\n");

  509.             chunk_type = CHUNK_BAD;

  510.             break;

  511. 

  512.         }

  513.     }

  514. 

  515.     /* make a note of where the stream is sitting */

  516.     s->next_chunk_offset = avio_tell(pb);

  517. 

  518.     /* dispatch the first of any pending packets */

  519.     if ((chunk_type == CHUNK_VIDEO) || (chunk_type == CHUNK_AUDIO_ONLY))

  520.         chunk_type = load_ipmovie_packet(s, pb, pkt);

  521. 

  522.     return chunk_type;

  523. }

  524. 

  525. static const char signature[] = "Interplay MVE File\x1A\0\x1A";

  526. 

  527. static int ipmovie_probe(AVProbeData *p)

  528. {

  529.     uint8_t *b = p->buf;

  530.     uint8_t *b_end = p->buf + p->buf_size - sizeof(signature);

  531.     do {

  532.         if (memcmp(b++, signature, sizeof(signature)) == 0)

  533.             return AVPROBE_SCORE_MAX;

  534.     } while (b < b_end);

  535. 

  536.     return 0;

  537. }

  538. 

  539. static int ipmovie_read_header(AVFormatContext *s)

  540. {

  541.     IPMVEContext *ipmovie = s->priv_data;

  542.     AVIOContext *pb = s->pb;

  543.     AVPacket pkt;

  544.     AVStream *st;

  545.     unsigned char chunk_preamble[CHUNK_PREAMBLE_SIZE];

  546.     int chunk_type;

  547.     uint8_t signature_buffer[sizeof(signature)];

  548. 

  549.     avio_read(pb, signature_buffer, sizeof(signature_buffer));

  550.     while (memcmp(signature_buffer, signature, sizeof(signature))) {

  551.         memmove(signature_buffer, signature_buffer + 1, sizeof(signature_buffer) - 1);

  552.         signature_buffer[sizeof(signature_buffer) - 1] = avio_r8(pb);

  553.         if (pb->eof_reached)

  554.             return AVERROR_EOF;

  555.     }

  556.     /* initialize private context members */

  557.     ipmovie->video_pts = ipmovie->audio_frame_count = 0;

  558.     ipmovie->audio_chunk_offset = ipmovie->video_chunk_offset =

  559.     ipmovie->decode_map_chunk_offset = 0;

  560. 

  561.     /* on the first read, this will position the stream at the first chunk */

  562.     ipmovie->next_chunk_offset = avio_tell(pb) + 4;

  563. 

  564.     /* process the first chunk which should be CHUNK_INIT_VIDEO */

  565.     if (process_ipmovie_chunk(ipmovie, pb, &pkt) != CHUNK_INIT_VIDEO)

  566.         return AVERROR_INVALIDDATA;

  567. 

  568.     /* peek ahead to the next chunk-- if it is an init audio chunk, process

  569.      * it; if it is the first video chunk, this is a silent file */

  570.     if (avio_read(pb, chunk_preamble, CHUNK_PREAMBLE_SIZE) !=

  571.         CHUNK_PREAMBLE_SIZE)

  572.         return AVERROR(EIO);

  573.     chunk_type = AV_RL16(&chunk_preamble[2]);

  574.     avio_seek(pb, -CHUNK_PREAMBLE_SIZE, SEEK_CUR);

  575. 

  576.     if (chunk_type == CHUNK_VIDEO)

  577.         ipmovie->audio_type = AV_CODEC_ID_NONE;  /* no audio */

  578.     else if (process_ipmovie_chunk(ipmovie, pb, &pkt) != CHUNK_INIT_AUDIO)

  579.         return AVERROR_INVALIDDATA;

  580. 

  581.     /* initialize the stream decoders */

  582.     st = avformat_new_stream(s, NULL);

  583.     if (!st)

  584.         return AVERROR(ENOMEM);

  585.     avpriv_set_pts_info(st, 63, 1, 1000000);

  586.     ipmovie->video_stream_index = st->index;

  587.     st->codec->codec_type = AVMEDIA_TYPE_VIDEO;

  588.     st->codec->codec_id = AV_CODEC_ID_INTERPLAY_VIDEO;

  589.     st->codec->codec_tag = 0;  /* no fourcc */

  590.     st->codec->width = ipmovie->video_width;

  591.     st->codec->height = ipmovie->video_height;

  592.     st->codec->bits_per_coded_sample = ipmovie->video_bpp;

  593. 

  594.     if (ipmovie->audio_type) {

  595.         st = avformat_new_stream(s, NULL);

  596.         if (!st)

  597.             return AVERROR(ENOMEM);

  598.         avpriv_set_pts_info(st, 32, 1, ipmovie->audio_sample_rate);

  599.         ipmovie->audio_stream_index = st->index;

  600.         st->codec->codec_type = AVMEDIA_TYPE_AUDIO;

  601.         st->codec->codec_id = ipmovie->audio_type;

  602.         st->codec->codec_tag = 0;  /* no tag */

  603.         st->codec->channels = ipmovie->audio_channels;

  604.         st->codec->channel_layout = st->codec->channels == 1 ? AV_CH_LAYOUT_MONO :

  605.                                                                AV_CH_LAYOUT_STEREO;

  606.         st->codec->sample_rate = ipmovie->audio_sample_rate;

  607.         st->codec->bits_per_coded_sample = ipmovie->audio_bits;

  608.         st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *

  609.             st->codec->bits_per_coded_sample;

  610.         if (st->codec->codec_id == AV_CODEC_ID_INTERPLAY_DPCM)

  611.             st->codec->bit_rate /= 2;

  612.         st->codec->block_align = st->codec->channels * st->codec->bits_per_coded_sample;

  613.     }

  614. 

  615.     return 0;

  616. }

  617. 

  618. static int ipmovie_read_packet(AVFormatContext *s,

  619.                                AVPacket *pkt)

  620. {

  621.     IPMVEContext *ipmovie = s->priv_data;

  622.     AVIOContext *pb = s->pb;

  623.     int ret;

  624. 

  625.     ret = process_ipmovie_chunk(ipmovie, pb, pkt);

  626.     if (ret == CHUNK_BAD)

  627.         ret = AVERROR_INVALIDDATA;

  628.     else if (ret == CHUNK_EOF)

  629.         ret = AVERROR(EIO);

  630.     else if (ret == CHUNK_NOMEM)

  631.         ret = AVERROR(ENOMEM);

  632.     else if (ret == CHUNK_VIDEO)

  633.         ret = 0;

  634.     else

  635.         ret = -1;

  636. 

  637.     return ret;

  638. }

  639. 

  640. AVInputFormat ff_ipmovie_demuxer = {

  641.     .name           = "ipmovie",

  642.     .long_name      = NULL_IF_CONFIG_SMALL("Interplay MVE"),

  643.     .priv_data_size = sizeof(IPMVEContext),

  644.     .read_probe     = ipmovie_probe,

  645.     .read_header    = ipmovie_read_header,

  646.     .read_packet    = ipmovie_read_packet,

  647. };