Changeset 263


Ignore:
Timestamp:
Nov 20, 2006, 9:45:29 PM (18 years ago)
Author:
vladest
Message:

FFMPEG update
significal changes - avi/mpegts/mpegps now handled by ffmpeg demuxer. From my point of view it works much more corrdctly

Location:
trunk
Files:
102 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified trunk/audio/adecode.c

    r261 r263  
    768768
    769769    RecAudioBuffer = Buffer;
    770     //printf("%i\n",BufferSize);
     770    //printf("cb: %i\n",BufferSize);
    771771
    772772    return BufferSize;
    … …  
    12611261    case CODEC_FFMPEG:
    12621262        {
     1263            int need_parser = 0;
    12631264            avcodec_init();
    12641265            avcodec_register_all();
    … …  
    12811282            case AUDIO_MP3:
    12821283                audio_codec = (AVCodec *)avcodec_find_decoder(CODEC_ID_MP3);
    1283                 if (audio_codec)
    1284                     av_parser = av_parser_init(audio_codec->id);
     1284                need_parser = 1;
    12851285                break;
    12861286
    12871287            case AUDIO_MP2:
    12881288                audio_codec = (AVCodec *)avcodec_find_decoder(CODEC_ID_MP2);
     1289                //need_parser = 1;
    12891290                break;
    12901291
    … …  
    13591360            }
    13601361
     1362            if (need_parser)
     1363                av_parser = av_parser_init(audio_codec->id);
    13611364            //            memset(audio_context, 0, sizeof(AVCodecContext));
    13621365            sh_audio->audio_out_minsize=AVCODEC_MAX_AUDIO_FRAME_SIZE;
    … …  
    13841387            if (!audio_context->bits_per_sample)
    13851388                audio_context->bits_per_sample = 1;
     1389            //if (!audio_context->sample_rate)
     1390            //    audio_context->sample_rate = 48000;
    13861391            audio_context->codec_tag = sh_audio->format;
    13871392            audio_context->codec_id = audio_codec->id;
    … …  
    14231428                sr = audio_context->sample_rate;
    14241429                if (!sh_audio->i_bps) sh_audio->i_bps = 1; // temporary
    1425                 max_count = 1000;
     1430                max_count = 3;
    14261431                while (i < max_count)
    14271432                {
    … …  
    15021507            }
    15031508        }
     1509        if (!sh_audio->samplerate)
     1510            sh_audio->samplerate = 48000;
    15041511        break;
    15051512    }
    … …  
    15941601#endif
    15951602    }
     1603    audio_reset();
    15961604    //    audio_header.sample_rate *= PlaySpeed;
    15971605    if (sh_audio->samplesize)
    … …  
    18371845        memset(sh_audio->codec,0,sizeof(codecs_st));
    18381846    }
     1847
     1848    /*printf("cp2\n");fflush(stdout);*/
    18391849}
    18401850
    … …  
    22502260
    22512261                //sh_audio->a_in_buffer_len += /*-1*/enc_len;
    2252 #if 1
     2262                //fprintf(stderr, "header: 0x%08X\n", *(unsigned int*)data);
     2263#if 0
    22532264                hdr = 0;
    22542265                // get mp2/mp3 header
    … …  
    23142325                    parse_data = NULL;
    23152326                    parse_size = 0;
    2316                     if (av_parser->parser->parser_init)
    2317                         av_parser->parser->parser_init(av_parser);
     2327//                    if (av_parser->parser->parser_init)
     2328//                        av_parser->parser->parser_init(av_parser);
    23182329
    23192330                parse_again:
    … …  
    23222333                                                &parse_data, &parse_size,
    23232334                                                data, enc_len,
    2324                                                 //AV_NOPTS_VALUE, AV_NOPTS_VALUE);
    2325                                                 av_pts, av_dts);
     2335                                                AV_NOPTS_VALUE, AV_NOPTS_VALUE);
     2336                                                //av_pts, av_dts);
    23262337#if 0
    23272338                    printf("data: %x, enclen: %i, p data: %x, p size: %i, p len: %i\n",
    … …  
    23382349                        //enc_len -= parse_len;
    23392350                        //goto new_packet;
    2340                         return 0;
     2351                        dprintf("AUDIO PARSER: Wrong parser size\n");
     2352                        //return 0;
    23412353                    } else
    23422354                    {
     2355                        dprintf("AUDIO PARSER: parser len: %i. enc len: %i\n", parse_len, enc_len);
    23432356                        if (enc_len == parse_len)
    23442357                        {
    … …  
    23492362                            data += parse_len;
    23502363                            enc_len -= parse_len;
     2364                           
    23512365                        }
    23522366                    }

  • TabularUnified trunk/gui/guieng/loadpng.cpp

    r64 r263  
    14351435
    14361436/* Table of CRCs of all 8-bit messages. */
    1437 unsigned long crc_table[256] =
     1437unsigned int crc_table[256] =
    14381438{
    143914390, 1996959894, 3993919788, 2567524794, 124634137, 1886057615, 3915621685, 2657392035,

  • TabularUnified trunk/gui/play.hpp

    r262 r263  
    20032003    no_audio = FALSE;
    20042004    no_video = FALSE;
    2005     //    printf("releasing: demuxer and stream closed\n");fflush(stdout);
    20062005    if (videobuffer!=NULL)
    20072006    {
    … …  
    23782377    ppl->demuxerType = demuxerM->type;
    23792378
    2380     if ((demuxerM->type == DEMUXER_TYPE_AVI_NI) ||
    2381         (demuxerM->type == DEMUXER_TYPE_AVI_NINI) ||
    2382         (demuxerM->type == DEMUXER_TYPE_MOV) ||
    2383         (CacheEnabled == FALSE))
    2384     {
    2385         printf("Cache disabled\n");
    2386         cache_disable();
    2387     }
    2388 
    23892379    if (!justprop)
    23902380    {
    … …  
    24432433        }
    24442434    }
     2435
     2436    if ((demuxerM->type == DEMUXER_TYPE_AVI_NI) ||
     2437        (demuxerM->type == DEMUXER_TYPE_AVI_NINI) ||
     2438        (demuxerM->type == DEMUXER_TYPE_MOV) ||
     2439        (CacheEnabled == FALSE) ||
     2440        (demuxerM->type == DEMUXER_TYPE_LAVF && sh_video &&
     2441         (sh_video->format == mmioFOURCC('S','V','Q','3') ||
     2442          sh_video->format == mmioFOURCC('S','V','Q','1') ||
     2443          sh_video->format == mmioFOURCC('V','P','3','1'))))
     2444    {
     2445        printf("Cache disabled\n");
     2446        cache_disable();
     2447    }
    24452448    if (hWndShowClient)
    24462449        WinPostMsg(hWndShowClient,WM_COMMAND, MPFROM2SHORT(IDM_REPAINT,0L),NULL);
    … …  
    30683071//    printf("audfree 1\n");fflush(stdout);
    30693072    if (!no_video && sh_video) video_close(sh_video);
    3070 
    30713073    StreamRelease();
    30723074

  • TabularUnified trunk/gui/version.h

    r262 r263  
    1 #define VERSION "9 Nov 2006"
     1#define VERSION "20 Nov 2006"

  • TabularUnified trunk/gui/video2.hpp

    r259 r263  
    376376sub_data* subtitles=NULL;
    377377subtitle* sub_curr=NULL;
     378int dvdsub_id=-2;
    378379extern subtitle* vo_sub;
    379380extern int vo_sub_changed;

  • TabularUnified trunk/libavcodec/8bps.c

    r256 r263  
    4040
    4141
    42 const enum PixelFormat pixfmt_rgb24[] = {PIX_FMT_BGR24, PIX_FMT_RGBA32, -1};
     42static const enum PixelFormat pixfmt_rgb24[] = {PIX_FMT_BGR24, PIX_FMT_RGBA32, -1};
    4343
    4444/*

  • TabularUnified trunk/libavcodec/allcodecs.c

    r261 r263  
    470470    register_avcodec(&sonic_decoder);
    471471#endif //CONFIG_SONIC_DECODER
    472 #ifdef CONFIG_AC3
     472#ifdef CONFIG_A52
    473473#ifdef CONFIG_AC3_DECODER
    474474    register_avcodec(&ac3_decoder);
    … …  
    870870    av_register_bitstream_filter(&remove_extradata_bsf);
    871871    av_register_bitstream_filter(&noise_bsf);
     872    av_register_bitstream_filter(&mp3_header_compress_bsf);
     873    av_register_bitstream_filter(&mp3_header_decompress_bsf);
    872874}
    873875

  • TabularUnified trunk/libavcodec/avcodec.h

    r262 r263  
    3131extern "C" {
    3232#endif
     33
    3334#include "config.h"
    3435#include "avutil.h"
    … …  
    26632664extern AVBitStreamFilter remove_extradata_bsf;
    26642665extern AVBitStreamFilter noise_bsf;
     2666extern AVBitStreamFilter mp3_header_compress_bsf;
     2667extern AVBitStreamFilter mp3_header_decompress_bsf;
    26652668
    26662669

  • TabularUnified trunk/libavcodec/bitstream_filter.c

    r256 r263  
    2020
    2121#include "avcodec.h"
     22#include "mpegaudio.h"
    2223
    2324AVBitStreamFilter *first_bitstream_filter= NULL;
    … …  
    125126}
    126127
     128#define MP3_MASK 0xFFFE0CCF
     129
     130static int mp3_header_compress(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args,
     131                     uint8_t **poutbuf, int *poutbuf_size,
     132                     const uint8_t *buf, int buf_size, int keyframe){
     133    uint32_t header, extraheader;
     134    int mode_extension, header_size;
     135
     136    if(avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL){
     137        av_log(avctx, AV_LOG_ERROR, "not standards compliant\n");
     138        return -1;
     139    }
     140
     141    header = BE_32(buf);
     142    mode_extension= (header>>4)&3;
     143
     144    if(ff_mpa_check_header(header) < 0 || (header&0x60000) != 0x20000){
     145output_unchanged:
     146        *poutbuf= (uint8_t *) buf;
     147        *poutbuf_size= buf_size;
     148
     149        av_log(avctx, AV_LOG_INFO, "cannot compress %08X\n", header);
     150        return 0;
     151    }
     152
     153    if(avctx->extradata_size == 0){
     154        avctx->extradata_size=15;
     155        avctx->extradata= av_malloc(avctx->extradata_size);
     156        strcpy(avctx->extradata, "FFCMP3 0.0");
     157        memcpy(avctx->extradata+11, buf, 4);
     158    }
     159    if(avctx->extradata_size != 15){
     160        av_log(avctx, AV_LOG_ERROR, "Extradata invalid\n");
     161        return -1;
     162    }
     163    extraheader = BE_32(avctx->extradata+11);
     164    if((extraheader&MP3_MASK) != (header&MP3_MASK))
     165        goto output_unchanged;
     166
     167    header_size= (header&0x10000) ? 4 : 6;
     168
     169    *poutbuf_size= buf_size - header_size;
     170    *poutbuf= av_malloc(buf_size - header_size + FF_INPUT_BUFFER_PADDING_SIZE);
     171    memcpy(*poutbuf, buf + header_size, buf_size - header_size + FF_INPUT_BUFFER_PADDING_SIZE);
     172
     173    if(avctx->channels==2){
     174        if((header & (3<<19)) != 3<<19){
     175            (*poutbuf)[1] &= 0x3F;
     176            (*poutbuf)[1] |= mode_extension<<6;
     177            FFSWAP(int, (*poutbuf)[1], (*poutbuf)[2]);
     178        }else{
     179            (*poutbuf)[1] &= 0x8F;
     180            (*poutbuf)[1] |= mode_extension<<4;
     181        }
     182    }
     183
     184    return 1;
     185}
     186
     187static int mp3_header_decompress(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args,
     188                     uint8_t **poutbuf, int *poutbuf_size,
     189                     const uint8_t *buf, int buf_size, int keyframe){
     190    uint32_t header;
     191    int sample_rate= avctx->sample_rate;
     192    int sample_rate_index=0;
     193    int lsf, mpeg25, bitrate_index, frame_size;
     194
     195    header = BE_32(buf);
     196    if(ff_mpa_check_header(header) >= 0){
     197        *poutbuf= (uint8_t *) buf;
     198        *poutbuf_size= buf_size;
     199
     200        return 0;
     201    }
     202
     203    if(avctx->extradata_size != 15 || strcmp(avctx->extradata, "FFCMP3 0.0")){
     204        av_log(avctx, AV_LOG_ERROR, "Extradata invalid %d\n", avctx->extradata_size);
     205        return -1;
     206    }
     207
     208    header= BE_32(avctx->extradata+11) & MP3_MASK;
     209
     210    lsf     = sample_rate < (24000+32000)/2;
     211    mpeg25  = sample_rate < (12000+16000)/2;
     212    sample_rate_index= (header>>10)&3;
     213    sample_rate= mpa_freq_tab[sample_rate_index] >> (lsf + mpeg25); //in case sample rate is a little off
     214
     215    for(bitrate_index=2; bitrate_index<30; bitrate_index++){
     216        frame_size = mpa_bitrate_tab[lsf][2][bitrate_index>>1];
     217        frame_size = (frame_size * 144000) / (sample_rate << lsf) + (bitrate_index&1);
     218        if(frame_size == buf_size + 4)
     219            break;
     220        if(frame_size == buf_size + 6)
     221            break;
     222    }
     223    if(bitrate_index == 30){
     224        av_log(avctx, AV_LOG_ERROR, "couldnt find bitrate_index\n");
     225        return -1;
     226    }
     227
     228    header |= (bitrate_index&1)<<9;
     229    header |= (bitrate_index>>1)<<12;
     230    header |= (frame_size == buf_size + 4)<<16; //FIXME actually set a correct crc instead of 0
     231
     232    *poutbuf_size= frame_size;
     233    *poutbuf= av_malloc(frame_size + FF_INPUT_BUFFER_PADDING_SIZE);
     234    memcpy(*poutbuf + frame_size - buf_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
     235
     236    if(avctx->channels==2){
     237        uint8_t *p= *poutbuf + frame_size - buf_size;
     238        if(lsf){
     239            FFSWAP(int, p[1], p[2]);
     240            header |= (p[1] & 0xC0)>>2;
     241            p[1] &= 0x3F;
     242        }else{
     243            header |= p[1] & 0x30;
     244            p[1] &= 0xCF;
     245        }
     246    }
     247
     248    (*poutbuf)[0]= header>>24;
     249    (*poutbuf)[1]= header>>16;
     250    (*poutbuf)[2]= header>> 8;
     251    (*poutbuf)[3]= header    ;
     252
     253    return 1;
     254}
     255
    127256AVBitStreamFilter dump_extradata_bsf={
    128257    "dump_extra",
    … …  
    142271    noise,
    143272};
     273
     274AVBitStreamFilter mp3_header_compress_bsf={
     275    "mp3comp",
     276    0,
     277    mp3_header_compress,
     278};
     279
     280AVBitStreamFilter mp3_header_decompress_bsf={
     281    "mp3decomp",
     282    0,
     283    mp3_header_decompress,
     284};

  • TabularUnified trunk/libavcodec/cavs.c

    r256 r263  
    3232#include "cavsdata.h"
    3333
     34#ifdef CONFIG_CAVS_DECODER
    3435typedef struct {
    3536    MpegEncContext s;
    … …  
    294295    int ih = 0;
    295296    int iv = 0;
    296     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     297    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    297298
    298299    for(x=0; x<4; x++) {
    … …  
    13191320}
    13201321
    1321 /**
    1322  * finds the end of the current frame in the bitstream.
    1323  * @return the position of the first byte of the next frame, or -1
    1324  */
    1325 int ff_cavs_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size) {
    1326     int pic_found, i;
    1327     uint32_t state;
    1328 
    1329     pic_found= pc->frame_start_found;
    1330     state= pc->state;
    1331 
    1332     i=0;
    1333     if(!pic_found){
    1334         for(i=0; i<buf_size; i++){
    1335             state= (state<<8) | buf[i];
    1336             if(state == PIC_I_START_CODE || state == PIC_PB_START_CODE){
    1337                 i++;
    1338                 pic_found=1;
    1339                 break;
    1340             }
    1341         }
    1342     }
    1343 
    1344     if(pic_found){
    1345         /* EOF considered as end of frame */
    1346         if (buf_size == 0)
    1347             return 0;
    1348         for(; i<buf_size; i++){
    1349             state= (state<<8) | buf[i];
    1350             if((state&0xFFFFFF00) == 0x100){
    1351                 if(state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE){
    1352                     pc->frame_start_found=0;
    1353                     pc->state=-1;
    1354                     return i-3;
    1355                 }
    1356             }
    1357         }
    1358     }
    1359     pc->frame_start_found= pic_found;
    1360     pc->state= state;
    1361     return END_NOT_FOUND;
    1362 }
    1363 
    1364 void ff_cavs_flush(AVCodecContext * avctx) {
     1322static void cavs_flush(AVCodecContext * avctx) {
    13651323    AVSContext *h = avctx->priv_data;
    13661324    h->got_keyframe = 0;
    … …  
    14991457    cavs_decode_frame,
    15001458    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
    1501     .flush= ff_cavs_flush,
     1459    .flush= cavs_flush,
    15021460};
     1461#endif /* CONFIG_CAVS_DECODER */
     1462
     1463#ifdef CONFIG_CAVSVIDEO_PARSER
     1464/**
     1465 * finds the end of the current frame in the bitstream.
     1466 * @return the position of the first byte of the next frame, or -1
     1467 */
     1468static int cavs_find_frame_end(ParseContext *pc, const uint8_t *buf,
     1469                               int buf_size) {
     1470    int pic_found, i;
     1471    uint32_t state;
     1472
     1473    pic_found= pc->frame_start_found;
     1474    state= pc->state;
     1475
     1476    i=0;
     1477    if(!pic_found){
     1478        for(i=0; i<buf_size; i++){
     1479            state= (state<<8) | buf[i];
     1480            if(state == PIC_I_START_CODE || state == PIC_PB_START_CODE){
     1481                i++;
     1482                pic_found=1;
     1483                break;
     1484            }
     1485        }
     1486    }
     1487
     1488    if(pic_found){
     1489        /* EOF considered as end of frame */
     1490        if (buf_size == 0)
     1491            return 0;
     1492        for(; i<buf_size; i++){
     1493            state= (state<<8) | buf[i];
     1494            if((state&0xFFFFFF00) == 0x100){
     1495                if(state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE){
     1496                    pc->frame_start_found=0;
     1497                    pc->state=-1;
     1498                    return i-3;
     1499                }
     1500            }
     1501        }
     1502    }
     1503    pc->frame_start_found= pic_found;
     1504    pc->state= state;
     1505    return END_NOT_FOUND;
     1506}
     1507
     1508static int cavsvideo_parse(AVCodecParserContext *s,
     1509                           AVCodecContext *avctx,
     1510                           uint8_t **poutbuf, int *poutbuf_size,
     1511                           const uint8_t *buf, int buf_size)
     1512{
     1513    ParseContext *pc = s->priv_data;
     1514    int next;
     1515
     1516    if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
     1517        next= buf_size;
     1518    }else{
     1519        next= cavs_find_frame_end(pc, buf, buf_size);
     1520
     1521        if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
     1522            *poutbuf = NULL;
     1523            *poutbuf_size = 0;
     1524            return buf_size;
     1525        }
     1526    }
     1527    *poutbuf = (uint8_t *)buf;
     1528    *poutbuf_size = buf_size;
     1529    return next;
     1530}
     1531
     1532AVCodecParser cavsvideo_parser = {
     1533    { CODEC_ID_CAVS },
     1534    sizeof(ParseContext1),
     1535    NULL,
     1536    cavsvideo_parse,
     1537    ff_parse1_close,
     1538    ff_mpeg4video_split,
     1539};
     1540#endif /* CONFIG_CAVSVIDEO_PARSER */

  • TabularUnified trunk/libavcodec/cavsdata.h

    r256 r263  
    132132};
    133133
     134#ifdef CONFIG_CAVS_DECODER
    134135static const uint8_t partition_flags[30] = {
    135136  0,                                 //I_8X8
    … …  
    640641static const int_fast8_t left_modifier_c[7] = { 5,-1, 2,-1, 6, 5, 6};
    641642static const int_fast8_t top_modifier_c[7]  = { 4, 1,-1,-1, 4, 6, 6};
     643#endif /* CONFIG_CAVS_DECODER */

  • TabularUnified trunk/libavcodec/cavsdsp.c

    r256 r263  
    185185    int i;
    186186    DCTELEM (*src)[8] = (DCTELEM(*)[8])block;
    187     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     187    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    188188
    189189    src[0][0] += 8;
    … …  
    261261static void OPNAME ## cavs_filt8_h_ ## NAME(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
    262262    const int h=8;\
    263     uint8_t *cm = cropTbl + MAX_NEG_CROP;\
     263    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
    264264    int i;\
    265265    for(i=0; i<h; i++)\
    … …  
    280280static void OPNAME ## cavs_filt8_v_  ## NAME(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
    281281    const int w=8;\
    282     uint8_t *cm = cropTbl + MAX_NEG_CROP;\
     282    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
    283283    int i;\
    284284    for(i=0; i<w; i++)\
    … …  
    334334    const int h=8;\
    335335    const int w=8;\
    336     uint8_t *cm = cropTbl + MAX_NEG_CROP;\
     336    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
    337337    int i;\
    338338    src1 -= 2*srcStride;\

  • TabularUnified trunk/libavcodec/dsputil.c

    r257 r263  
    4141void vorbis_inverse_coupling(float *mag, float *ang, int blocksize);
    4242
    43 uint8_t cropTbl[256 + 2 * MAX_NEG_CROP] = {0, };
    44 uint32_t squareTbl[512] = {0, };
     43uint8_t ff_cropTbl[256 + 2 * MAX_NEG_CROP] = {0, };
     44uint32_t ff_squareTbl[512] = {0, };
    4545
    4646const uint8_t ff_zigzag_direct[64] = {
    … …  
    9494
    9595/* a*inverse[b]>>32 == a/b for all 0<=a<=65536 && 2<=b<=255 */
    96 const uint32_t inverse[256]={
     96const uint32_t ff_inverse[256]={
    9797         0, 4294967295U,2147483648U,1431655766, 1073741824,  858993460,  715827883,  613566757,
    9898 536870912,  477218589,  429496730,  390451573,  357913942,  330382100,  306783379,  286331154,
    … …  
    166166{
    167167    int s, i, j;
    168     uint32_t *sq = squareTbl + 256;
     168    uint32_t *sq = ff_squareTbl + 256;
    169169
    170170    s = 0;
    … …  
    232232{
    233233    int s, i;
    234     uint32_t *sq = squareTbl + 256;
     234    uint32_t *sq = ff_squareTbl + 256;
    235235
    236236    s = 0;
    … …  
    249249{
    250250    int s, i;
    251     uint32_t *sq = squareTbl + 256;
     251    uint32_t *sq = ff_squareTbl + 256;
    252252
    253253    s = 0;
    … …  
    270270{
    271271    int s, i;
    272     uint32_t *sq = squareTbl + 256;
     272    uint32_t *sq = ff_squareTbl + 256;
    273273
    274274    s = 0;
    … …  
    437437{
    438438    int i;
    439     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     439    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    440440
    441441    /* read the pixels */
    … …  
    459459{
    460460    int i;
    461     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     461    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    462462
    463463    /* read the pixels */
    … …  
    477477{
    478478    int i;
    479     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     479    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    480480
    481481    /* read the pixels */
    … …  
    514514{
    515515    int i;
    516     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     516    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    517517
    518518    /* read the pixels */
    … …  
    535535{
    536536    int i;
    537     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     537    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    538538
    539539    /* read the pixels */
    … …  
    552552{
    553553    int i;
    554     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     554    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    555555
    556556    /* read the pixels */
    … …  
    15931593#define QPEL_MC(r, OPNAME, RND, OP) \
    15941594static void OPNAME ## mpeg4_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
    1595     uint8_t *cm = cropTbl + MAX_NEG_CROP;\
     1595    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
    15961596    int i;\
    15971597    for(i=0; i<h; i++)\
    … …  
    16121612static void OPNAME ## mpeg4_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
    16131613    const int w=8;\
    1614     uint8_t *cm = cropTbl + MAX_NEG_CROP;\
     1614    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
    16151615    int i;\
    16161616    for(i=0; i<w; i++)\
    … …  
    16391639\
    16401640static void OPNAME ## mpeg4_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
    1641     uint8_t *cm = cropTbl + MAX_NEG_CROP;\
     1641    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
    16421642    int i;\
    16431643    \
    … …  
    16661666\
    16671667static void OPNAME ## mpeg4_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
    1668     uint8_t *cm = cropTbl + MAX_NEG_CROP;\
     1668    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
    16691669    int i;\
    16701670    const int w=16;\
    … …  
    20922092static void OPNAME ## h264_qpel2_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
    20932093    const int h=2;\
    2094     uint8_t *cm = cropTbl + MAX_NEG_CROP;\
     2094    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
    20952095    int i;\
    20962096    for(i=0; i<h; i++)\
    … …  
    21052105static void OPNAME ## h264_qpel2_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
    21062106    const int w=2;\
    2107     uint8_t *cm = cropTbl + MAX_NEG_CROP;\
     2107    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
    21082108    int i;\
    21092109    for(i=0; i<w; i++)\
    … …  
    21262126    const int h=2;\
    21272127    const int w=2;\
    2128     uint8_t *cm = cropTbl + MAX_NEG_CROP;\
     2128    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
    21292129    int i;\
    21302130    src -= 2*srcStride;\
    … …  
    21542154static void OPNAME ## h264_qpel4_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
    21552155    const int h=4;\
    2156     uint8_t *cm = cropTbl + MAX_NEG_CROP;\
     2156    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
    21572157    int i;\
    21582158    for(i=0; i<h; i++)\
    … …  
    21692169static void OPNAME ## h264_qpel4_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
    21702170    const int w=4;\
    2171     uint8_t *cm = cropTbl + MAX_NEG_CROP;\
     2171    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
    21722172    int i;\
    21732173    for(i=0; i<w; i++)\
    … …  
    21942194    const int h=4;\
    21952195    const int w=4;\
    2196     uint8_t *cm = cropTbl + MAX_NEG_CROP;\
     2196    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
    21972197    int i;\
    21982198    src -= 2*srcStride;\
    … …  
    22292229static void OPNAME ## h264_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
    22302230    const int h=8;\
    2231     uint8_t *cm = cropTbl + MAX_NEG_CROP;\
     2231    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
    22322232    int i;\
    22332233    for(i=0; i<h; i++)\
    … …  
    22482248static void OPNAME ## h264_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
    22492249    const int w=8;\
    2250     uint8_t *cm = cropTbl + MAX_NEG_CROP;\
     2250    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
    22512251    int i;\
    22522252    for(i=0; i<w; i++)\
    … …  
    22812281    const int h=8;\
    22822282    const int w=8;\
    2283     uint8_t *cm = cropTbl + MAX_NEG_CROP;\
     2283    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
    22842284    int i;\
    22852285    src -= 2*srcStride;\
    … …  
    25832583
    25842584static void wmv2_mspel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){
    2585     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     2585    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    25862586    int i;
    25872587
    … …  
    26282628
    26292629static void wmv2_mspel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int w){
    2630     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     2630    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    26312631    int i;
    26322632
    … …  
    38483848static void ff_jref_idct1_put(uint8_t *dest, int line_size, DCTELEM *block)
    38493849{
    3850     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     3850    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    38513851
    38523852    dest[0] = cm[(block[0] + 4)>>3];
    … …  
    38543854static void ff_jref_idct1_add(uint8_t *dest, int line_size, DCTELEM *block)
    38553855{
    3856     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     3856    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    38573857
    38583858    dest[0] = cm[dest[0] + ((block[0] + 4)>>3)];
    … …  
    38663866    int i;
    38673867
    3868     for(i=0;i<256;i++) cropTbl[i + MAX_NEG_CROP] = i;
     3868    for(i=0;i<256;i++) ff_cropTbl[i + MAX_NEG_CROP] = i;
    38693869    for(i=0;i<MAX_NEG_CROP;i++) {
    3870         cropTbl[i] = 0;
    3871         cropTbl[i + MAX_NEG_CROP + 256] = 255;
     3870        ff_cropTbl[i] = 0;
     3871        ff_cropTbl[i + MAX_NEG_CROP + 256] = 255;
    38723872    }
    38733873
    38743874    for(i=0;i<512;i++) {
    3875         squareTbl[i] = (i - 256) * (i - 256);
     3875        ff_squareTbl[i] = (i - 256) * (i - 256);
    38763876    }
    38773877

  • TabularUnified trunk/libavcodec/dsputil.h

    r256 r263  
    7575
    7676/* temporary */
    77 extern uint32_t squareTbl[512];
    78 extern uint8_t cropTbl[256 + 2 * MAX_NEG_CROP];
     77extern uint32_t ff_squareTbl[512];
     78extern uint8_t ff_cropTbl[256 + 2 * MAX_NEG_CROP];
    7979
    8080/* VP3 DSP functions */

  • TabularUnified trunk/libavcodec/dtsdec.c

    r256 r263  
    5656}
    5757
    58 void
     58static void
    5959convert2s16_2 (sample_t * _f, int16_t * s16)
    6060{
    … …  
    6969}
    7070
    71 void
     71static void
    7272convert2s16_4 (sample_t * _f, int16_t * s16)
    7373{
    … …  
    8484}
    8585
    86 void
     86static void
    8787convert2s16_5 (sample_t * _f, int16_t * s16)
    8888{

  • TabularUnified trunk/libavcodec/dvbsubdec.c

    r261 r263  
    345345    DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
    346346
    347     cm = cropTbl + MAX_NEG_CROP;
     347    cm = ff_cropTbl + MAX_NEG_CROP;
    348348
    349349    memset(avctx->priv_data, 0, sizeof(DVBSubContext));

  • TabularUnified trunk/libavcodec/error_resilience.c

    r257 r263  
    200200static void h_block_filter(MpegEncContext *s, uint8_t *dst, int w, int h, int stride, int is_luma){
    201201    int b_x, b_y;
    202     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     202    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    203203
    204204    for(b_y=0; b_y<h; b_y++){
    … …  
    260260static void v_block_filter(MpegEncContext *s, uint8_t *dst, int w, int h, int stride, int is_luma){
    261261    int b_x, b_y;
    262     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     262    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    263263
    264264    for(b_y=0; b_y<h-1; b_y++){

  • TabularUnified trunk/libavcodec/faac.c

    r256 r263  
    9696}
    9797
    98 int Faac_encode_frame(AVCodecContext *avctx,
    99                       unsigned char *frame, int buf_size, void *data)
     98static int Faac_encode_frame(AVCodecContext *avctx,
     99                             unsigned char *frame, int buf_size, void *data)
    100100{
    101101    FaacAudioContext *s = avctx->priv_data;
    … …  
    111111}
    112112
    113 int Faac_encode_close(AVCodecContext *avctx)
     113static int Faac_encode_close(AVCodecContext *avctx)
    114114{
    115115    FaacAudioContext *s = avctx->priv_data;

  • TabularUnified trunk/libavcodec/flicvideo.c

    r259 r263  
    157157    signed short line_packets;
    158158    int y_ptr;
    159     signed char byte_run;
     159    int byte_run;
    160160    int pixel_skip;
    161161    int pixel_countdown;
    … …  
    259259                        pixel_ptr += pixel_skip;
    260260                        pixel_countdown -= pixel_skip;
    261                         byte_run = buf[stream_ptr++];
     261                        byte_run = (signed char)(buf[stream_ptr++]);
    262262                        if (byte_run < 0) {
    263263                            byte_run = -byte_run;
    … …  
    302302                        pixel_ptr += pixel_skip;
    303303                        pixel_countdown -= pixel_skip;
    304                         byte_run = buf[stream_ptr++];
     304                        byte_run = (signed char)(buf[stream_ptr++]);
    305305                        if (byte_run > 0) {
    306306                            CHECK_PIXEL_PTR(byte_run);
    … …  
    342342                pixel_countdown = s->avctx->width;
    343343                while (pixel_countdown > 0) {
    344                     byte_run = buf[stream_ptr++];
     344                    byte_run = (signed char)(buf[stream_ptr++]);
    345345                    if (byte_run > 0) {
    346346                        palette_idx1 = buf[stream_ptr++];
    … …  
    444444    signed short line_packets;
    445445    int y_ptr;
    446     signed char byte_run;
     446    int byte_run;
    447447    int pixel_skip;
    448448    int pixel_countdown;
    … …  
    504504                        pixel_ptr += (pixel_skip*2); /* Pixel is 2 bytes wide */
    505505                        pixel_countdown -= pixel_skip;
    506                         byte_run = buf[stream_ptr++];
     506                        byte_run = (signed char)(buf[stream_ptr++]);
    507507                        if (byte_run < 0) {
    508508                            byte_run = -byte_run;
    … …  
    550550
    551551                while (pixel_countdown > 0) {
    552                     byte_run = buf[stream_ptr++];
     552                    byte_run = (signed char)(buf[stream_ptr++]);
    553553                    if (byte_run > 0) {
    554554                        palette_idx1 = buf[stream_ptr++];
    … …  
    604604
    605605                while (pixel_countdown > 0) {
    606                     byte_run = buf[stream_ptr++];
     606                    byte_run = (signed char)(buf[stream_ptr++]);
    607607                    if (byte_run > 0) {
    608608                        pixel    = LE_16(&buf[stream_ptr]);

  • TabularUnified trunk/libavcodec/h261.c

    r256 r263  
    7878}
    7979
    80 static int ff_h261_get_picture_format(int width, int height){
     80int ff_h261_get_picture_format(int width, int height){
    8181    // QCIF
    8282    if (width == 176 && height == 144)

  • TabularUnified trunk/libavcodec/h261data.h

    r256 r263  
    2727
    2828// H.261 VLC table for macroblock addressing
    29 const uint8_t h261_mba_code[35] = {
     29static const uint8_t h261_mba_code[35] = {
    3030     1,  3,  2,  3,
    3131     2,  3,  2,  7,
    … …  
    4141};
    4242
    43 const uint8_t h261_mba_bits[35] = {
     43static const uint8_t h261_mba_bits[35] = {
    4444     1,  3,  3,  4,
    4545     4,  5,  5,  7,
    … …  
    5656
    5757//H.261 VLC table for macroblock type
    58 const uint8_t h261_mtype_code[10] = {
     58static const uint8_t h261_mtype_code[10] = {
    5959    1,  1,  1,  1,
    6060    1,  1,  1,  1,
    … …  
    6262};
    6363
    64 const uint8_t h261_mtype_bits[10] = {
     64static const uint8_t h261_mtype_bits[10] = {
    6565    4,  7,  1,  5,
    6666    9,  8, 10,  3,
    … …  
    8282
    8383//H.261 VLC table for motion vectors
    84 const uint8_t h261_mv_tab[17][2] = {
     84static const uint8_t h261_mv_tab[17][2] = {
    8585    {1,1}, {1,2}, {1,3}, {1,4}, {3,6}, {5,7}, {4,7}, {3,7},
    8686    {11,9}, {10,9}, {9,9}, {17,10}, {16,10}, {15,10}, {14,10}, {13,10}, {12,10}
    … …  
    9393
    9494//H.261 VLC table for coded block pattern
    95 const uint8_t h261_cbp_tab[63][2] =
     95static const uint8_t h261_cbp_tab[63][2] =
    9696{
    9797    {11,5}, {9,5}, {13,6}, {13,4}, {23,7}, {19,7}, {31,8}, {12,4},
    … …  
    106106
    107107//H.261 VLC table for transform coefficients
    108 const uint16_t h261_tcoeff_vlc[65][2] = {
     108static const uint16_t h261_tcoeff_vlc[65][2] = {
    109109{ 0x2, 2 }, { 0x3, 2 },{ 0x4, 4 },{ 0x5, 5 },
    110110{ 0x6, 7 },{ 0x26, 8 },{ 0x21, 8 },{ 0xa, 10 },
    … …  
    126126};
    127127
    128 const int8_t h261_tcoeff_level[64] = {
     128static const int8_t h261_tcoeff_level[64] = {
    129129    0,  1,  2,  3,  4,  5,  6,  7,
    130130    8,  9, 10, 11, 12, 13, 14, 15,
    … …  
    137137};
    138138
    139 const int8_t h261_tcoeff_run[64] = {
     139static const int8_t h261_tcoeff_run[64] = {
    140140    0,
    141141    0,  0,  0,  0,  0,  0,  0,  0,

  • TabularUnified trunk/libavcodec/h263data.h

    r256 r263  
    8989};
    9090
    91 const uint8_t cbpc_b_tab[4][2] = {
     91static const uint8_t cbpc_b_tab[4][2] = {
    9292{0, 1},
    9393{2, 2},
    … …  
    181181};
    182182
    183 const uint16_t intra_vlc_aic[103][2] = {
     183static const uint16_t intra_vlc_aic[103][2] = {
    184184{  0x2,  2 }, {  0x6,  3 }, {  0xe,  4 }, {  0xc,  5 },
    185185{  0xd,  5 }, { 0x10,  6 }, { 0x11,  6 }, { 0x12,  6 },
    … …  
    210210};
    211211
    212 const int8_t intra_run_aic[102] = {
     212static const int8_t intra_run_aic[102] = {
    213213 0,  0,  0,  0,  0,  0,  0,  0,
    214214 0,  0,  0,  0,  0,  0,  0,  0,
    … …  
    226226};
    227227
    228 const int8_t intra_level_aic[102] = {
     228static const int8_t intra_level_aic[102] = {
    229229 1,  2,  3,  4,  5,  6,  7,  8,
    230230 9, 10, 11, 12, 13, 14, 15, 16,

  • TabularUnified trunk/libavcodec/h264.c

    r262 r263  
    24522452  int i, j, k;
    24532453  int a;
    2454   uint8_t *cm = cropTbl + MAX_NEG_CROP;
     2454  uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    24552455  const uint8_t * const src0 = src+7-stride;
    24562456  const uint8_t *src1 = src+8*stride-1;
    … …  
    25952595  int j, k;
    25962596  int a;
    2597   uint8_t *cm = cropTbl + MAX_NEG_CROP;
     2597  uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    25982598  const uint8_t * const src0 = src+3-stride;
    25992599  const uint8_t *src1 = src+4*stride-1;

  • TabularUnified trunk/libavcodec/h264idct.c

    r256 r263  
    3131static always_inline void idct_internal(uint8_t *dst, DCTELEM *block, int stride, int block_stride, int shift, int add){
    3232    int i;
    33     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     33    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    3434
    3535    block[0] += 1<<(shift-1);
    … …  
    7575    int i;
    7676    DCTELEM (*src)[8] = (DCTELEM(*)[8])block;
    77     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     77    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    7878
    7979    block[0] += 32;
    … …  
    146146void ff_h264_idct_dc_add_c(uint8_t *dst, DCTELEM *block, int stride){
    147147    int i, j;
    148     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     148    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    149149    int dc = (block[0] + 32) >> 6;
    150150    for( j = 0; j < 4; j++ )
    … …  
    158158void ff_h264_idct8_dc_add_c(uint8_t *dst, DCTELEM *block, int stride){
    159159    int i, j;
    160     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     160    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    161161    int dc = (block[0] + 32) >> 6;
    162162    for( j = 0; j < 8; j++ )

  • TabularUnified trunk/libavcodec/i386/dsputil_mmx.c

    r261 r263  
    26682668
    26692669#define PREFETCH(name, op) \
    2670 void name(void *mem, int stride, int h){\
     2670static void name(void *mem, int stride, int h){\
    26712671    const uint8_t *p= mem;\
    26722672    do{\
    … …  
    30083008}
    30093009
    3010 void float_to_int16_3dnow(int16_t *dst, const float *src, int len){
     3010static void float_to_int16_3dnow(int16_t *dst, const float *src, int len){
    30113011    // not bit-exact: pf2id uses different rounding than C and SSE
    30123012    int i;
    … …  
    30233023    asm volatile("femms");
    30243024}
    3025 void float_to_int16_sse(int16_t *dst, const float *src, int len){
     3025static void float_to_int16_sse(int16_t *dst, const float *src, int len){
    30263026    int i;
    30273027    for(i=0; i<len; i+=4) {

  • TabularUnified trunk/libavcodec/i386/fdct_mmx.c

    r256 r263  
    6868static const int32_t fdct_r_row[2] ATTR_ALIGN(8) = {RND_FRW_ROW, RND_FRW_ROW };
    6969
    70 struct
     70static struct
    7171{
    7272 const int32_t fdct_r_row_sse2[4] ATTR_ALIGN(16);
    … …  
    151151};
    152152
    153 struct
     153static struct
    154154{
    155155 const int16_t tab_frw_01234567_sse2[256] ATTR_ALIGN(16);

  • TabularUnified trunk/libavcodec/i386/mpegvideo_mmx.c

    r256 r263  
    2828#include "x86_cpu.h"
    2929
    30 extern uint8_t zigzag_direct_noperm[64];
    3130extern uint16_t inv_zigzag_direct16[64];
    3231

  • TabularUnified trunk/libavcodec/i386/mpegvideo_mmx_template.c

    r256 r263  
    7777                "mul %%ecx                \n\t"
    7878                : "=d" (level), "=a"(dummy)
    79                 : "a" ((block[0]>>2) + q), "c" (inverse[q<<1])
     79                : "a" ((block[0]>>2) + q), "c" (ff_inverse[q<<1])
    8080        );
    8181#else

  • TabularUnified trunk/libavcodec/imgconvert.c

    r261 r263  
    186186    [PIX_FMT_RGB555] = {
    187187        .name = "rgb555",
    188         .nb_channels = 4, .is_alpha = 1,
     188        .nb_channels = 3,
    189189        .color_type = FF_COLOR_RGB,
    190190        .pixel_type = FF_PIXEL_PACKED,
    … …  
    270270    [PIX_FMT_BGR555] = {
    271271        .name = "bgr555",
    272         .nb_channels = 4, .is_alpha = 1,
     272        .nb_channels = 3,
    273273        .color_type = FF_COLOR_RGB,
    274274        .pixel_type = FF_PIXEL_PACKED,
    … …  
    12421242{
    12431243    int i;
    1244     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     1244    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    12451245
    12461246    for(i = 0;i < 256; i++) {
    … …  
    16301630}
    16311631
    1632 #define RGBA_IN(r, g, b, a, s)\
     1632
     1633#define RGB_OUT(d, r, g, b)\
    16331634{\
    1634     unsigned int v = ((const uint16_t *)(s))[0];\
    1635     r = bitcopy_n(v >> (10 - 3), 3);\
    1636     g = bitcopy_n(v >> (5 - 3), 3);\
    1637     b = bitcopy_n(v << 3, 3);\
    1638     a = (-(v >> 15)) & 0xff;\
    1639 }
    1640 
    1641 #define RGBA_OUT(d, r, g, b, a)\
    1642 {\
    1643     ((uint16_t *)(d))[0] = ((r >> 3) << 10) | ((g >> 3) << 5) | (b >> 3) | \
    1644                            ((a << 8) & 0x8000);\
     1635    ((uint16_t *)(d))[0] = ((r >> 3) << 10) | ((g >> 3) << 5) | (b >> 3);\
    16451636}
    16461637
    … …  
    20612052            .convert = rgba32_to_rgb24
    20622053        },
     2054        [PIX_FMT_BGR24] = {
     2055            .convert = rgba32_to_bgr24
     2056        },
     2057        [PIX_FMT_RGB565] = {
     2058            .convert = rgba32_to_rgb565
     2059        },
    20632060        [PIX_FMT_RGB555] = {
    20642061            .convert = rgba32_to_rgb555
    … …  
    20752072    },
    20762073    [PIX_FMT_BGR24] = {
     2074        [PIX_FMT_RGBA32] = {
     2075            .convert = bgr24_to_rgba32
     2076        },
    20772077        [PIX_FMT_RGB24] = {
    20782078            .convert = bgr24_to_rgb24
    … …  
    21002100    },
    21012101    [PIX_FMT_RGB565] = {
     2102        [PIX_FMT_RGBA32] = {
     2103            .convert = rgb565_to_rgba32
     2104        },
    21022105        [PIX_FMT_RGB24] = {
    21032106            .convert = rgb565_to_rgb24
    … …  
    25852588        ret = get_alpha_info_rgba32(src, width, height);
    25862589        break;
    2587     case PIX_FMT_RGB555:
    2588         ret = get_alpha_info_rgb555(src, width, height);
    2589         break;
    25902590    case PIX_FMT_PAL8:
    25912591        ret = get_alpha_info_pal8(src, width, height);
    … …  
    26542654{
    26552655#ifndef HAVE_MMX
    2656     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     2656    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    26572657    int sum;
    26582658
    … …  
    26972697{
    26982698#ifndef HAVE_MMX
    2699     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     2699    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    27002700    int sum;
    27012701

  • TabularUnified trunk/libavcodec/imgconvert_template.h

    r256 r263  
    3030    uint8_t *d, *d1, *d2;
    3131    int w, y, cb, cr, r_add, g_add, b_add, width2;
    32     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     32    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    3333    unsigned int r, g, b;
    3434
    … …  
    124124    uint8_t *d, *d1, *d2;
    125125    int w, y, cb, cr, r_add, g_add, b_add, width2;
    126     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     126    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    127127    unsigned int r, g, b;
    128128
    … …  
    411411}
    412412
    413 #if !defined(FMT_RGBA32) && defined(RGBA_OUT)
     413// RGB24 has optimised routines
     414#if !defined(FMT_RGBA32) && !defined(FMT_RGB24)
    414415/* alpha support */
    415416
    … …  
    420421    uint8_t *d;
    421422    int src_wrap, dst_wrap, j, y;
    422     unsigned int v, r, g, b, a;
     423    unsigned int v, r, g, b;
     424#ifdef RGBA_OUT
     425    unsigned int a;
     426#endif
    423427
    424428    s = src->data[0];
    … …  
    431435        for(j = 0;j < width; j++) {
    432436            v = ((const uint32_t *)(s))[0];
    433             a = (v >> 24) & 0xff;
    434437            r = (v >> 16) & 0xff;
    435438            g = (v >> 8) & 0xff;
    436439            b = v & 0xff;
     440#ifdef RGBA_OUT
     441            a = (v >> 24) & 0xff;
    437442            RGBA_OUT(d, r, g, b, a);
     443#else
     444            RGB_OUT(d, r, g, b);
     445#endif
    438446            s += 4;
    439447            d += BPP;
    … …  
    450458    uint8_t *d;
    451459    int src_wrap, dst_wrap, j, y;
    452     unsigned int r, g, b, a;
     460    unsigned int r, g, b;
     461#ifdef RGBA_IN
     462    unsigned int a;
     463#endif
    453464
    454465    s = src->data[0];
    … …  
    460471    for(y=0;y<height;y++) {
    461472        for(j = 0;j < width; j++) {
     473#ifdef RGBA_IN
    462474            RGBA_IN(r, g, b, a, s);
    463475            ((uint32_t *)(d))[0] = (a << 24) | (r << 16) | (g << 8) | b;
     476#else
     477            RGB_IN(r, g, b, s);
     478            ((uint32_t *)(d))[0] = (0xff << 24) | (r << 16) | (g << 8) | b;
     479#endif
    464480            d += 4;
    465481            s += BPP;
    … …  
    470486}
    471487
    472 #endif /* !defined(FMT_RGBA32) && defined(RGBA_IN) */
     488#endif /* !defined(FMT_RGBA32) */
    473489
    474490#ifndef FMT_RGB24
    … …  
    540556    uint8_t *d, *d1;
    541557    int w, y, cb, cr, r_add, g_add, b_add;
    542     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     558    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    543559    unsigned int r, g, b;
    544560
    … …  
    573589    uint8_t *d, *d1;
    574590    int w, y, cb, cr, r_add, g_add, b_add;
    575     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     591    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    576592    unsigned int r, g, b;
    577593

  • TabularUnified trunk/libavcodec/mjpeg.c

    r261 r263  
    855855    int lossless;
    856856    int ls;
     857    int progressive;
    857858    int rgb;
    858859    int rct;            /* standard rct */
    … …  
    886887    ScanTable scantable;
    887888    void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
     889    void (*idct_add)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
    888890
    889891    int restart_interval;
    … …  
    942944    s->scantable= s2.intra_scantable;
    943945    s->idct_put= s2.dsp.idct_put;
     946    s->idct_add= s2.dsp.idct_add;
    944947
    945948    s->mpeg_enc_ctx_allocated = 0;
    … …  
    12521255    }
    12531256
     1257    /* totally blank picture as progressive JPEG will only add details to it */
     1258    if(s->progressive){
     1259        memset(s->picture.data[0], 0, s->picture.linesize[0] * s->height);
     1260        memset(s->picture.data[1], 0, s->picture.linesize[1] * s->height >> (s->v_max - s->v_count[1]));
     1261        memset(s->picture.data[2], 0, s->picture.linesize[2] * s->height >> (s->v_max - s->v_count[2]));
     1262    }
    12541263    return 0;
    12551264}
    … …  
    13221331            j = s->scantable.permutated[i];
    13231332            block[j] = level * quant_matrix[j];
     1333        }
     1334    }
     1335    CLOSE_READER(re, &s->gb)}
     1336
     1337    return 0;
     1338}
     1339
     1340/* decode block and dequantize - progressive JPEG version */
     1341static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block,
     1342                        int component, int dc_index, int ac_index, int16_t *quant_matrix,
     1343                        int ss, int se, int Ah, int Al, int *EOBRUN)
     1344{
     1345    int code, i, j, level, val, run;
     1346
     1347    /* DC coef */
     1348    if(!ss){
     1349        val = mjpeg_decode_dc(s, dc_index);
     1350        if (val == 0xffff) {
     1351            dprintf("error dc\n");
     1352            return -1;
     1353        }
     1354        val = (val * quant_matrix[0] << Al) + s->last_dc[component];
     1355    }else
     1356        val = 0;
     1357    s->last_dc[component] = val;
     1358    block[0] = val;
     1359    if(!se) return 0;
     1360    /* AC coefs */
     1361    if(*EOBRUN){
     1362        (*EOBRUN)--;
     1363        return 0;
     1364    }
     1365    {OPEN_READER(re, &s->gb)
     1366    for(i=ss;;i++) {
     1367        UPDATE_CACHE(re, &s->gb);
     1368        GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)
     1369        /* Progressive JPEG use AC coeffs from zero and this decoder sets offset 16 by default */
     1370        code -= 16;
     1371        if(code & 0xF) {
     1372            i += ((unsigned) code) >> 4;
     1373            code &= 0xf;
     1374            if(code > MIN_CACHE_BITS - 16){
     1375                UPDATE_CACHE(re, &s->gb)
     1376            }
     1377            {
     1378                int cache=GET_CACHE(re,&s->gb);
     1379                int sign=(~cache)>>31;
     1380                level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
     1381            }
     1382
     1383            LAST_SKIP_BITS(re, &s->gb, code)
     1384
     1385            if (i >= se) {
     1386                if(i == se){
     1387                    j = s->scantable.permutated[se];
     1388                    block[j] = level * quant_matrix[j] << Al;
     1389                    break;
     1390                }
     1391                dprintf("error count: %d\n", i);
     1392                return -1;
     1393            }
     1394            j = s->scantable.permutated[i];
     1395            block[j] = level * quant_matrix[j] << Al;
     1396        }else{
     1397            run = ((unsigned) code) >> 4;
     1398            if(run == 0xF){// ZRL - skip 15 coefficients
     1399                i += 15;
     1400            }else{
     1401                val = run;
     1402                run = (1 << run);
     1403                UPDATE_CACHE(re, &s->gb);
     1404                run += (GET_CACHE(re, &s->gb) >> (32 - val)) & (run - 1);
     1405                if(val)
     1406                    LAST_SKIP_BITS(re, &s->gb, val);
     1407                *EOBRUN = run - 1;
     1408                break;
     1409            }
    13241410        }
    13251411    }
    … …  
    14801566}
    14811567
    1482 static int mjpeg_decode_scan(MJpegDecodeContext *s){
     1568static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int ss, int se, int Ah, int Al){
    14831569    int i, mb_x, mb_y;
    1484     const int nb_components=3;
    1485 
     1570    int EOBRUN = 0;
     1571
     1572    if(Ah) return 0; /* TODO decode refinement planes too */
    14861573    for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
    14871574        for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
    … …  
    15001587                for(j=0;j<n;j++) {
    15011588                    memset(s->block, 0, sizeof(s->block));
    1502                     if (decode_block(s, s->block, i,
     1589                    if (!s->progressive && decode_block(s, s->block, i,
    15031590                                     s->dc_index[i], s->ac_index[i],
    15041591                                     s->quant_matrixes[ s->quant_index[c] ]) < 0) {
     1592                        dprintf("error y=%d x=%d\n", mb_y, mb_x);
     1593                        return -1;
     1594                    }
     1595                    if (s->progressive && decode_block_progressive(s, s->block, i,
     1596                                     s->dc_index[i], s->ac_index[i],
     1597                                     s->quant_matrixes[ s->quant_index[c] ], ss, se, Ah, Al, &EOBRUN) < 0) {
    15051598                        dprintf("error y=%d x=%d\n", mb_y, mb_x);
    15061599                        return -1;
    … …  
    15131606                        ptr += s->linesize[c] >> 1;
    15141607//av_log(NULL, AV_LOG_DEBUG, "%d %d %d %d %d %d %d %d \n", mb_x, mb_y, x, y, c, s->bottom_field, (v * mb_y + y) * 8, (h * mb_x + x) * 8);
    1515                     s->idct_put(ptr, s->linesize[c], s->block);
     1608                    if(!s->progressive)
     1609                        s->idct_put(ptr, s->linesize[c], s->block);
     1610                    else
     1611                        s->idct_add(ptr, s->linesize[c], s->block);
    15161612                    if (++x == h) {
    15171613                        x = 0;
    … …  
    15381634    int vmax, hmax, index, id;
    15391635    const int block_size= s->lossless ? 1 : 8;
    1540     int ilv;
     1636    int ilv, prev_shift;
    15411637
    15421638    /* XXX: verify len field validity */
    … …  
    15491645    }
    15501646    /* XXX: only interleaved scan accepted */
    1551     if ((nb_components != s->nb_components) && !s->ls)
     1647    if ((nb_components != s->nb_components) && !s->ls && !s->progressive)
    15521648    {
    15531649        dprintf("decode_sos: components(%d) mismatch\n", nb_components);
    … …  
    16031699    predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
    16041700    ilv= get_bits(&s->gb, 8);    /* JPEG Se / JPEG-LS ILV */
    1605     skip_bits(&s->gb, 4); /* Ah */
     1701    prev_shift = get_bits(&s->gb, 4); /* Ah */
    16061702    point_transform= get_bits(&s->gb, 4); /* Al */
    16071703
    … …  
    16491745        }
    16501746    }else{
    1651         if(mjpeg_decode_scan(s) < 0)
     1747        if(mjpeg_decode_scan(s, nb_components, predictor, ilv, prev_shift, point_transform) < 0)
    16521748            return -1;
    16531749    }
    … …  
    20382134                case SOF0:
    20392135                    s->lossless=0;
     2136                    s->progressive=0;
     2137                    if (mjpeg_decode_sof(s) < 0)
     2138                        return -1;
     2139                    break;
     2140                case SOF2:
     2141                    s->lossless=0;
     2142                    s->progressive=1;
    20402143                    if (mjpeg_decode_sof(s) < 0)
    20412144                        return -1;
    … …  
    20432146                case SOF3:
    20442147                    s->lossless=1;
     2148                    s->progressive=0;
    20452149                    if (mjpeg_decode_sof(s) < 0)
    20462150                        return -1;
    … …  
    20492153                    s->lossless=1;
    20502154                    s->ls=1;
     2155                    s->progressive=0;
    20512156                    if (mjpeg_decode_sof(s) < 0)
    20522157                        return -1;
    … …  
    20952200                    break;
    20962201                case SOF1:
    2097                 case SOF2:
    20982202                case SOF5:
    20992203                case SOF6:

  • TabularUnified trunk/libavcodec/mp3lameaudio.c

    r261 r263  
    136136}
    137137
    138 int MP3lame_encode_frame(AVCodecContext *avctx,
    139                      unsigned char *frame, int buf_size, void *data)
     138static int MP3lame_encode_frame(AVCodecContext *avctx,
     139                                unsigned char *frame, int buf_size, void *data)
    140140{
    141141    Mp3AudioContext *s = avctx->priv_data;
    … …  
    199199}
    200200
    201 int MP3lame_encode_close(AVCodecContext *avctx)
     201static int MP3lame_encode_close(AVCodecContext *avctx)
    202202{
    203203    Mp3AudioContext *s = avctx->priv_data;

  • TabularUnified trunk/libavcodec/mpeg12.c

    r262 r263  
    8686#endif
    8787
    88 const enum PixelFormat pixfmt_yuv_420[]= {PIX_FMT_YUV420P,-1};
    89 const enum PixelFormat pixfmt_yuv_422[]= {PIX_FMT_YUV422P,-1};
    90 const enum PixelFormat pixfmt_yuv_444[]= {PIX_FMT_YUV444P,-1};
    91 const enum PixelFormat pixfmt_xvmc_mpg2_420[] = {
     88static const enum PixelFormat pixfmt_yuv_420[]= {PIX_FMT_YUV420P,-1};
     89static const enum PixelFormat pixfmt_yuv_422[]= {PIX_FMT_YUV422P,-1};
     90static const enum PixelFormat pixfmt_yuv_444[]= {PIX_FMT_YUV444P,-1};
     91static const enum PixelFormat pixfmt_xvmc_mpg2_420[] = {
    9292                                           PIX_FMT_XVMC_MPEG2_IDCT,
    9393                                           PIX_FMT_XVMC_MPEG2_MC,

  • TabularUnified trunk/libavcodec/mpeg12data.h

    r256 r263  
    5555};
    5656
    57 const uint16_t vlc_dc_chroma_code[12] = {
     57static const uint16_t vlc_dc_chroma_code[12] = {
    5858    0x0, 0x1, 0x2, 0x6, 0xe, 0x1e, 0x3e, 0x7e, 0xfe, 0x1fe, 0x3fe, 0x3ff,
    5959};
    60 const unsigned char vlc_dc_chroma_bits[12] = {
     60static const unsigned char vlc_dc_chroma_bits[12] = {
    6161    2, 2, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10,
    6262};

  • TabularUnified trunk/libavcodec/mpegaudio.h

    r261 r263  
    9090
    9191/* fast header check for resync */
     92#if 1
     93static inline int ff_mpa_check_header(uint32_t header){
     94    if ((header & 0xffe00000) != 0xffe00000)
     95        return -1;
     96    if (!((header >> 17) & 3))
     97        return -1;
     98    if (((header >> 12) & 0xf) == 0xf)
     99        return -1;
     100    if (((header >> 10) & 0x3) == 0x3)
     101        return -1;
     102    return 0;
     103}
     104#else
    92105static inline int ff_mpa_check_header(uint32_t header){
    93106    /* header */
    … …  
    105118    return 0;
    106119}
     120#endif

  • TabularUnified trunk/libavcodec/mpegaudiodec.c

    r261 r263  
    9090    int adu_mode; ///< 0 for standard mp3, 1 for adu formatted mp3
    9191    int dither_state;
     92    int error_resilience;
    9293} MPADecodeContext;
    9394
    … …  
    306307    avctx->sample_fmt= SAMPLE_FMT_S16;
    307308#endif
     309    s->error_resilience= avctx->error_resilience;
    308310
    309311    if(avctx->antialias_algo != FF_AA_FLOAT)
    … …  
    17051707                s_index -= 4;
    17061708                skip_bits_long(&s->gb, last_pos - pos);
    1707                 //av_log(NULL, AV_LOG_INFO, "overread, skip %d enddists: %d %d\n", last_pos - pos, end_pos-pos, end_pos2-pos);
     1709                av_log(NULL, AV_LOG_INFO, "overread, skip %d enddists: %d %d\n", last_pos - pos, end_pos-pos, end_pos2-pos);
     1710                if(s->error_resilience >= FF_ER_COMPLIANT)
     1711                    s_index=0;
    17081712                break;
    17091713            }
    … …  
    17431747        s_index+=4;
    17441748    }
    1745     memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid)*(576 - s_index));
    1746 
    17471749    /* skip extension bits */
    17481750    bits_left = end_pos - get_bits_count(&s->gb);
    17491751//av_log(NULL, AV_LOG_ERROR, "left:%d buf:%p\n", bits_left, s->in_gb.buffer);
    1750     if (bits_left < 0) {
    1751         dprintf("bits_left=%d\n", bits_left);
    1752         return -1;
    1753     }
     1752    if (bits_left < 0 || bits_left > 16) {
     1753        av_log(NULL, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
     1754        s_index=0;
     1755    }else if(bits_left > 0 && s->error_resilience >= FF_ER_AGGRESSIVE){
     1756        av_log(NULL, AV_LOG_ERROR, "bits_left=%d\n", bits_left);
     1757        s_index=0;
     1758    }
     1759    memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid)*(576 - s_index));
    17541760    skip_bits_long(&s->gb, bits_left);
    17551761
    … …  
    21672173            g->part2_3_length = get_bits(&s->gb, 12);
    21682174            g->big_values = get_bits(&s->gb, 9);
     2175            if(g->big_values > 288){
     2176                av_log(NULL, AV_LOG_ERROR, "big_values too big\n");
     2177                return -1;
     2178            }
     2179
    21692180            g->global_gain = get_bits(&s->gb, 8);
    21702181            /* if MS stereo only is selected, we precompute the
    … …  
    21802191            if (blocksplit_flag) {
    21812192                g->block_type = get_bits(&s->gb, 2);
    2182                 if (g->block_type == 0)
     2193                if (g->block_type == 0){
     2194                    av_log(NULL, AV_LOG_ERROR, "invalid block type\n");
    21832195                    return -1;
     2196                }
    21842197                g->switch_point = get_bits(&s->gb, 1);
    21852198                for(i=0;i<2;i++)
    … …  
    22682281    dprintf("seekback: %d\n", main_data_begin);
    22692282//av_log(NULL, AV_LOG_ERROR, "backstep:%d, lastbuf:%d\n", main_data_begin, s->last_buf_size);
    2270     if(main_data_begin > s->last_buf_size){
    2271         //av_log(NULL, AV_LOG_ERROR, "backstep:%d, lastbuf:%d\n", main_data_begin, s->last_buf_size);
    2272 //        s->last_buf_size= main_data_begin;
    2273         return -1;
    2274       }
    22752283
    22762284    memcpy(s->last_buf + s->last_buf_size, ptr, EXTRABYTES);
    22772285    s->in_gb= s->gb;
    2278     init_get_bits(&s->gb, s->last_buf + s->last_buf_size - main_data_begin, main_data_begin*8);
     2286        init_get_bits(&s->gb, s->last_buf, s->last_buf_size*8);
     2287        skip_bits_long(&s->gb, 8*(s->last_buf_size - main_data_begin));
    22792288  }
    22802289
    … …  
    22822291        for(ch=0;ch<s->nb_channels;ch++) {
    22832292            g = &granules[ch][gr];
     2293            if(get_bits_count(&s->gb)<0){
     2294                av_log(NULL, AV_LOG_ERROR, "mdb:%d, lastbuf:%d skiping granule %d\n",
     2295                                            main_data_begin, s->last_buf_size, gr);
     2296                skip_bits_long(&s->gb, g->part2_3_length);
     2297                memset(g->sb_hybrid, 0, sizeof(g->sb_hybrid));
     2298                if(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->in_gb.buffer){
     2299                    skip_bits_long(&s->in_gb, get_bits_count(&s->gb) - s->gb.size_in_bits);
     2300                    s->gb= s->in_gb;
     2301                    s->in_gb.buffer=NULL;
     2302                }
     2303                continue;
     2304            }
    22842305
    22852306            bits_pos = get_bits_count(&s->gb);
    … …  
    24122433
    24132434            /* read Huffman coded residue */
    2414             if (huffman_decode(s, g, exponents,
    2415                                bits_pos + g->part2_3_length) < 0)
    2416                 return -1;
     2435            huffman_decode(s, g, exponents, bits_pos + g->part2_3_length);
    24172436#if defined(DEBUG)
    24182437            sample_dump(0, g->sb_hybrid, 576);
    … …  
    24402459        }
    24412460    } /* gr */
     2461    if(get_bits_count(&s->gb)<0)
     2462        skip_bits_long(&s->gb, -get_bits_count(&s->gb));
    24422463    return nb_granules * 18;
    24432464}
    … …  
    24772498                av_log(NULL, AV_LOG_ERROR, "invalid old backstep %d\n", i);
    24782499            s->gb= s->in_gb;
     2500            s->in_gb.buffer= NULL;
    24792501        }
    24802502
    … …  
    24842506
    24852507        if(i<0 || i > BACKSTEP_SIZE || nb_frames<0){
    2486             //av_log(NULL, AV_LOG_ERROR, "invalid new backstep %d\n", i);
     2508            av_log(NULL, AV_LOG_ERROR, "invalid new backstep %d\n", i);
    24872509            i= FFMIN(BACKSTEP_SIZE, buf_size - HEADER_SIZE);
    24882510        }
    … …  
    25372559    if(ff_mpa_check_header(header) < 0){
    25382560        buf++;
    2539 //        buf_size--;
    2540         av_log(avctx, AV_LOG_ERROR, "Header missing skipping one byte.\n");
     2561        //buf_size--;
     2562        av_log(avctx, AV_LOG_ERROR, "Header missing skipping one byte. 0x%08X\n", header);
    25412563        goto retry;
    25422564    }
    … …  
    25702592        return -1;
    25712593    }else if(s->frame_size < buf_size){
    2572         av_log(avctx, AV_LOG_ERROR, "incorrect frame size\n");
     2594        av_log(avctx, AV_LOG_ERROR, "incorrect frame size. %i->%i\n", s->frame_size, buf_size);
    25732595    }
    25742596
    … …  
    25822604    s->frame_size = 0;
    25832605    return buf_size;
     2606}
     2607
     2608static void flush(AVCodecContext *avctx){
     2609    MPADecodeContext *s = avctx->priv_data;
     2610    s->last_buf_size= 0;
    25842611}
    25852612
    … …  
    28192846    decode_frame,
    28202847    CODEC_CAP_PARSE_ONLY,
     2848    .flush= flush,
    28212849};
    28222850#endif
    … …  
    28332861    decode_frame_adu,
    28342862    CODEC_CAP_PARSE_ONLY,
     2863    .flush= flush,
    28352864};
    28362865#endif
    … …  
    28462875    decode_close_mp3on4,
    28472876    decode_frame_mp3on4,
    2848     0
     2877    .flush= flush,
    28492878};
    28502879#endif

  • TabularUnified trunk/libavcodec/mpegaudiodectab.h

    r256 r263  
    243243/* mpegaudio layer 3 huffman tables */
    244244
    245 const uint16_t mpa_huffcodes_1[4] = {
     245static const uint16_t mpa_huffcodes_1[4] = {
    246246 0x0001, 0x0001, 0x0001, 0x0000,
    247247};
    248248
    249 const uint8_t mpa_huffbits_1[4] = {
     249static const uint8_t mpa_huffbits_1[4] = {
    250250  1,  3,  2,  3,
    251251};
    252252
    253 const uint16_t mpa_huffcodes_2[9] = {
     253static const uint16_t mpa_huffcodes_2[9] = {
    254254 0x0001, 0x0002, 0x0001, 0x0003, 0x0001, 0x0001, 0x0003, 0x0002,
    255255 0x0000,
    256256};
    257257
    258 const uint8_t mpa_huffbits_2[9] = {
     258static const uint8_t mpa_huffbits_2[9] = {
    259259  1,  3,  6,  3,  3,  5,  5,  5,
    260260  6,
    261261};
    262262
    263 const uint16_t mpa_huffcodes_3[9] = {
     263static const uint16_t mpa_huffcodes_3[9] = {
    264264 0x0003, 0x0002, 0x0001, 0x0001, 0x0001, 0x0001, 0x0003, 0x0002,
    265265 0x0000,
    266266};
    267267
    268 const uint8_t mpa_huffbits_3[9] = {
     268static const uint8_t mpa_huffbits_3[9] = {
    269269  2,  2,  6,  3,  2,  5,  5,  5,
    270270  6,
    271271};
    272272
    273 const uint16_t mpa_huffcodes_5[16] = {
     273static const uint16_t mpa_huffcodes_5[16] = {
    274274 0x0001, 0x0002, 0x0006, 0x0005, 0x0003, 0x0001, 0x0004, 0x0004,
    275275 0x0007, 0x0005, 0x0007, 0x0001, 0x0006, 0x0001, 0x0001, 0x0000,
    276276};
    277277
    278 const uint8_t mpa_huffbits_5[16] = {
     278static const uint8_t mpa_huffbits_5[16] = {
    279279  1,  3,  6,  7,  3,  3,  6,  7,
    280280  6,  6,  7,  8,  7,  6,  7,  8,
    281281};
    282282
    283 const uint16_t mpa_huffcodes_6[16] = {
     283static const uint16_t mpa_huffcodes_6[16] = {
    284284 0x0007, 0x0003, 0x0005, 0x0001, 0x0006, 0x0002, 0x0003, 0x0002,
    285285 0x0005, 0x0004, 0x0004, 0x0001, 0x0003, 0x0003, 0x0002, 0x0000,
    286286};
    287287
    288 const uint8_t mpa_huffbits_6[16] = {
     288static const uint8_t mpa_huffbits_6[16] = {
    289289  3,  3,  5,  7,  3,  2,  4,  5,
    290290  4,  4,  5,  6,  6,  5,  6,  7,
    291291};
    292292
    293 const uint16_t mpa_huffcodes_7[36] = {
     293static const uint16_t mpa_huffcodes_7[36] = {
    294294 0x0001, 0x0002, 0x000a, 0x0013, 0x0010, 0x000a, 0x0003, 0x0003,
    295295 0x0007, 0x000a, 0x0005, 0x0003, 0x000b, 0x0004, 0x000d, 0x0011,
    … …  
    299299};
    300300
    301 const uint8_t mpa_huffbits_7[36] = {
     301static const uint8_t mpa_huffbits_7[36] = {
    302302  1,  3,  6,  8,  8,  9,  3,  4,
    303303  6,  7,  7,  8,  6,  5,  7,  8,
    … …  
    307307};
    308308
    309 const uint16_t mpa_huffcodes_8[36] = {
     309static const uint16_t mpa_huffcodes_8[36] = {
    310310 0x0003, 0x0004, 0x0006, 0x0012, 0x000c, 0x0005, 0x0005, 0x0001,
    311311 0x0002, 0x0010, 0x0009, 0x0003, 0x0007, 0x0003, 0x0005, 0x000e,
    … …  
    315315};
    316316
    317 const uint8_t mpa_huffbits_8[36] = {
     317static const uint8_t mpa_huffbits_8[36] = {
    318318  2,  3,  6,  8,  8,  9,  3,  2,
    319319  4,  8,  8,  8,  6,  4,  6,  8,
    … …  
    323323};
    324324
    325 const uint16_t mpa_huffcodes_9[36] = {
     325static const uint16_t mpa_huffcodes_9[36] = {
    326326 0x0007, 0x0005, 0x0009, 0x000e, 0x000f, 0x0007, 0x0006, 0x0004,
    327327 0x0005, 0x0005, 0x0006, 0x0007, 0x0007, 0x0006, 0x0008, 0x0008,
    … …  
    331331};
    332332
    333 const uint8_t mpa_huffbits_9[36] = {
     333static const uint8_t mpa_huffbits_9[36] = {
    334334  3,  3,  5,  6,  8,  9,  3,  3,
    335335  4,  5,  6,  8,  4,  4,  5,  6,
    … …  
    339339};
    340340
    341 const uint16_t mpa_huffcodes_10[64] = {
     341static const uint16_t mpa_huffcodes_10[64] = {
    342342 0x0001, 0x0002, 0x000a, 0x0017, 0x0023, 0x001e, 0x000c, 0x0011,
    343343 0x0003, 0x0003, 0x0008, 0x000c, 0x0012, 0x0015, 0x000c, 0x0007,
    … …  
    350350};
    351351
    352 const uint8_t mpa_huffbits_10[64] = {
     352static const uint8_t mpa_huffbits_10[64] = {
    353353  1,  3,  6,  8,  9,  9,  9, 10,
    354354  3,  4,  6,  7,  8,  9,  8,  8,
    … …  
    361361};
    362362
    363 const uint16_t mpa_huffcodes_11[64] = {
     363static const uint16_t mpa_huffcodes_11[64] = {
    364364 0x0003, 0x0004, 0x000a, 0x0018, 0x0022, 0x0021, 0x0015, 0x000f,
    365365 0x0005, 0x0003, 0x0004, 0x000a, 0x0020, 0x0011, 0x000b, 0x000a,
    … …  
    372372};
    373373
    374 const uint8_t mpa_huffbits_11[64] = {
     374static const uint8_t mpa_huffbits_11[64] = {
    375375  2,  3,  5,  7,  8,  9,  8,  9,
    376376  3,  3,  4,  6,  8,  8,  7,  8,
    … …  
    383383};
    384384
    385 const uint16_t mpa_huffcodes_12[64] = {
     385static const uint16_t mpa_huffcodes_12[64] = {
    386386 0x0009, 0x0006, 0x0010, 0x0021, 0x0029, 0x0027, 0x0026, 0x001a,
    387387 0x0007, 0x0005, 0x0006, 0x0009, 0x0017, 0x0010, 0x001a, 0x000b,
    … …  
    394394};
    395395
    396 const uint8_t mpa_huffbits_12[64] = {
     396static const uint8_t mpa_huffbits_12[64] = {
    397397  4,  3,  5,  7,  8,  9,  9,  9,
    398398  3,  3,  4,  5,  7,  7,  8,  8,
    … …  
    405405};
    406406
    407 const uint16_t mpa_huffcodes_13[256] = {
     407static const uint16_t mpa_huffcodes_13[256] = {
    408408 0x0001, 0x0005, 0x000e, 0x0015, 0x0022, 0x0033, 0x002e, 0x0047,
    409409 0x002a, 0x0034, 0x0044, 0x0034, 0x0043, 0x002c, 0x002b, 0x0013,
    … …  
    440440};
    441441
    442 const uint8_t mpa_huffbits_13[256] = {
     442static const uint8_t mpa_huffbits_13[256] = {
    443443  1,  4,  6,  7,  8,  9,  9, 10,
    444444  9, 10, 11, 11, 12, 12, 13, 13,
    … …  
    475475};
    476476
    477 const uint16_t mpa_huffcodes_15[256] = {
     477static const uint16_t mpa_huffcodes_15[256] = {
    478478 0x0007, 0x000c, 0x0012, 0x0035, 0x002f, 0x004c, 0x007c, 0x006c,
    479479 0x0059, 0x007b, 0x006c, 0x0077, 0x006b, 0x0051, 0x007a, 0x003f,
    … …  
    510510};
    511511
    512 const uint8_t mpa_huffbits_15[256] = {
     512static const uint8_t mpa_huffbits_15[256] = {
    513513  3,  4,  5,  7,  7,  8,  9,  9,
    514514  9, 10, 10, 11, 11, 11, 12, 13,
    … …  
    545545};
    546546
    547 const uint16_t mpa_huffcodes_16[256] = {
     547static const uint16_t mpa_huffcodes_16[256] = {
    548548 0x0001, 0x0005, 0x000e, 0x002c, 0x004a, 0x003f, 0x006e, 0x005d,
    549549 0x00ac, 0x0095, 0x008a, 0x00f2, 0x00e1, 0x00c3, 0x0178, 0x0011,
    … …  
    580580};
    581581
    582 const uint8_t mpa_huffbits_16[256] = {
     582static const uint8_t mpa_huffbits_16[256] = {
    583583  1,  4,  6,  8,  9,  9, 10, 10,
    584584 11, 11, 11, 12, 12, 12, 13,  9,
    … …  
    615615};
    616616
    617 const uint16_t mpa_huffcodes_24[256] = {
     617static const uint16_t mpa_huffcodes_24[256] = {
    618618 0x000f, 0x000d, 0x002e, 0x0050, 0x0092, 0x0106, 0x00f8, 0x01b2,
    619619 0x01aa, 0x029d, 0x028d, 0x0289, 0x026d, 0x0205, 0x0408, 0x0058,
    … …  
    650650};
    651651
    652 const uint8_t mpa_huffbits_24[256] = {
     652static const uint8_t mpa_huffbits_24[256] = {
    653653  4,  4,  6,  7,  8,  9,  9, 10,
    654654 10, 11, 11, 11, 11, 11, 12,  9,
    … …  
    685685};
    686686
    687 const HuffTable mpa_huff_tables[16] = {
     687static const HuffTable mpa_huff_tables[16] = {
    688688{ 1, NULL, NULL },
    689689{ 2, mpa_huffbits_1, mpa_huffcodes_1 },
    … …  
    704704};
    705705
    706 const uint8_t mpa_huff_data[32][2] = {
     706static const uint8_t mpa_huff_data[32][2] = {
    707707{ 0, 0 },
    708708{ 1, 0 },
    … …  
    752752
    753753/* band size tables */
    754 const uint8_t band_size_long[9][22] = {
     754static const uint8_t band_size_long[9][22] = {
    755755{ 4, 4, 4, 4, 4, 4, 6, 6, 8, 8, 10,
    756756  12, 16, 20, 24, 28, 34, 42, 50, 54, 76, 158, }, /* 44100 */
    … …  
    773773};
    774774
    775 const uint8_t band_size_short[9][13] = {
     775static const uint8_t band_size_short[9][13] = {
    776776{ 4, 4, 4, 4, 6, 8, 10, 12, 14, 18, 22, 30, 56, }, /* 44100 */
    777777{ 4, 4, 4, 4, 6, 6, 10, 12, 14, 16, 20, 26, 66, }, /* 48000 */
    … …  
    785785};
    786786
    787 const uint8_t mpa_pretab[2][22] = {
     787static const uint8_t mpa_pretab[2][22] = {
    788788    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
    789789    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 2, 0 },
    … …  
    791791
    792792/* table for alias reduction (XXX: store it as integer !) */
    793 const float ci_table[8] = {
     793static const float ci_table[8] = {
    794794    -0.6, -0.535, -0.33, -0.185, -0.095, -0.041, -0.0142, -0.0037,
    795795};

  • TabularUnified trunk/libavcodec/mpegvideo.c

    r262 r263  
    11051105    }
    11061106
     1107    if(s->flags & CODEC_FLAG_LOW_DELAY){
     1108        if (s->codec_id != CODEC_ID_MPEG2VIDEO && s->codec_id != CODEC_ID_MPEG1VIDEO){
     1109            av_log(avctx, AV_LOG_ERROR, "low delay forcing is only available for mpeg1/2\n");
     1110            return -1;
     1111        }
     1112        if (s->max_b_frames != 0){
     1113            av_log(avctx, AV_LOG_ERROR, "b frames cannot be used with low delay\n");
     1114            return -1;
     1115        }
     1116    }
     1117
    11071118    if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
    11081119       && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
    … …  
    11701181    case CODEC_ID_MPEG1VIDEO:
    11711182        s->out_format = FMT_MPEG1;
    1172         s->low_delay= 0; //s->max_b_frames ? 0 : 1;
     1183        s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY);
    11731184        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
    11741185        break;
    11751186    case CODEC_ID_MPEG2VIDEO:
    11761187        s->out_format = FMT_MPEG1;
    1177         s->low_delay= 0; //s->max_b_frames ? 0 : 1;
     1188        s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY);
    11781189        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
    11791190        s->rtp_mode= 1;
    … …  
    11971208        s->low_delay=1;
    11981209        break;
     1210#ifdef CONFIG_H261_ENCODER
    11991211    case CODEC_ID_H261:
     1212        if (ff_h261_get_picture_format(s->width, s->height) < 0) {
     1213            av_log(avctx, AV_LOG_ERROR, "The specified picture size of %dx%d is not valid for the H.261 codec.\nValid sizes are 176x144, 352x288\n", s->width, s->height);
     1214            return -1;
     1215        }
    12001216        s->out_format = FMT_H261;
    12011217        avctx->delay=0;
    12021218        s->low_delay=1;
    12031219        break;
     1220#endif
    12041221    case CODEC_ID_H263:
    12051222        if (h263_get_picture_format(s->width, s->height) == 7) {
    … …  
    25382555            if(put_bits_count(&s->pb) > max_size && s->lambda < s->avctx->lmax){
    25392556                s->next_lambda= FFMAX(s->lambda+1, s->lambda*(s->qscale+1) / s->qscale);
     2557                if(s->adaptive_quant){
     2558                    int i;
     2559                    for(i=0; i<s->mb_height*s->mb_width; i++)
     2560                        s->lambda_table[i]= FFMAX(s->lambda_table[i]+1, s->lambda_table[i]*(s->qscale+1) / s->qscale);
     2561                }
    25402562                s->mb_skipped = 0;        //done in MPV_frame_start()
    25412563                if(s->pict_type==P_TYPE){ //done in encode_picture() so we must undo it
    … …  
    47524774
    47534775static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
    4754     uint32_t *sq = squareTbl + 256;
     4776    uint32_t *sq = ff_squareTbl + 256;
    47554777    int acc=0;
    47564778    int x,y;
    … …  
    52125234                    if(best_s.mv_type==MV_TYPE_16X16 && !(best_s.mv_dir&MV_DIRECT)){
    52135235                        const int last_qp= backup_s.qscale;
    5214                         int dquant, dir, qp, dc[6];
     5236                        int qpi, qp, dc[6];
    52155237                        DCTELEM ac[6][16];
    52165238                        const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
     5239                        static const int dquant_tab[4]={-1,1,-2,2};
    52175240
    52185241                        assert(backup_s.dquant == 0);
    … …  
    52275250                        s->mv[1][0][1] = best_s.mv[1][0][1];
    52285251
    5229                         dir= s->pict_type == B_TYPE ? 2 : 1;
    5230                         if(last_qp + dir > s->avctx->qmax) dir= -dir;
    5231                         for(dquant= dir; dquant<=2 && dquant>=-2; dquant += dir){
     5252                        qpi = s->pict_type == B_TYPE ? 2 : 0;
     5253                        for(; qpi<4; qpi++){
     5254                            int dquant= dquant_tab[qpi];
    52325255                            qp= last_qp + dquant;
    52335256                            if(qp < s->avctx->qmin || qp > s->avctx->qmax)
    5234                                 break;
     5257                                continue;
    52355258                            backup_s.dquant= dquant;
    52365259                            if(s->mb_intra && s->dc_val[0]){
    … …  
    52505273                                    }
    52515274                                }
    5252                                 if(dir > 0 && dquant==dir){
    5253                                     dquant= 0;
    5254                                     dir= -dir;
    5255                                 }else
    5256                                     break;
    52575275                            }
    52585276                        }

  • TabularUnified trunk/libavcodec/mpegvideo.h

    r262 r263  
    825825void ff_h261_encode_picture_header(MpegEncContext * s, int picture_number);
    826826void ff_h261_encode_init(MpegEncContext *s);
     827int ff_h261_get_picture_format(int width, int height);
    827828
    828829

  • TabularUnified trunk/libavcodec/msmpeg4.c

    r261 r263  
    676676        "movl %%edx, %2         \n\t"
    677677        : "+b" (a), "+c" (b), "+D" (c)
    678         : "g" (scale), "S" (inverse[scale])
     678        : "g" (scale), "S" (ff_inverse[scale])
    679679        : "%eax", "%edx"
    680680    );

  • TabularUnified trunk/libavcodec/os2thread.c

    r256 r263  
    2525#include "avcodec.h"
    2626#include "common.h"
    27 
    28 #ifdef HAVE_THREADS
    2927
    3028#define INCL_DOS
    … …  
    148146    return -1;
    149147}
    150 #endif

  • TabularUnified trunk/libavcodec/os_support.h

    r147 r263  
    2727#include <stdlib.h>
    2828static inline int usleep(unsigned int t) { return _sleep2(t / 1000); }
    29 static inline int strcasecmp(const char* s1, const char* s2) { return stricmp(s1,s2); }
     29//static inline int strcasecmp(const char* s1, const char* s2) { return stricmp(s1,s2); }
    3030#endif
    3131

  • TabularUnified trunk/libavcodec/parser.c

    r262 r263  
    362362#endif
    363363
    364 #ifdef CONFIG_CAVSVIDEO_PARSER
    365 static int cavsvideo_parse(AVCodecParserContext *s,
    366                            AVCodecContext *avctx,
    367                            uint8_t **poutbuf, int *poutbuf_size,
    368                            const uint8_t *buf, int buf_size)
    369 {
    370     ParseContext *pc = s->priv_data;
    371     int next;
    372 
    373     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
    374         next= buf_size;
    375     }else{
    376         next= ff_cavs_find_frame_end(pc, buf, buf_size);
    377 
    378         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
    379             *poutbuf = NULL;
    380             *poutbuf_size = 0;
    381             return buf_size;
    382         }
    383     }
    384     *poutbuf = (uint8_t *)buf;
    385     *poutbuf_size = buf_size;
    386     return next;
    387 }
    388 #endif /* CONFIG_CAVSVIDEO_PARSER */
    389 
    390 static int mpeg4video_split(AVCodecContext *avctx,
     364int ff_mpeg4video_split(AVCodecContext *avctx,
    391365                           const uint8_t *buf, int buf_size)
    392366{
    … …  
    855829    mpeg4video_parse,
    856830    ff_parse1_close,
    857     mpeg4video_split,
    858 };
    859 #endif
    860 #ifdef CONFIG_CAVSVIDEO_PARSER
    861 AVCodecParser cavsvideo_parser = {
    862     { CODEC_ID_CAVS },
    863     sizeof(ParseContext1),
    864     NULL,
    865     cavsvideo_parse,
    866     ff_parse1_close,
    867     mpeg4video_split,
     831    ff_mpeg4video_split,
    868832};
    869833#endif

  • TabularUnified trunk/libavcodec/raw.c

    r262 r263  
    3838} PixelFormatTag;
    3939
    40 const PixelFormatTag pixelFormatTags[] = {
     40static const PixelFormatTag pixelFormatTags[] = {
    4141    { PIX_FMT_YUV420P, MKTAG('I', '4', '2', '0') }, /* Planar formats */
    4242    { PIX_FMT_YUV420P, MKTAG('I', 'Y', 'U', 'V') },

  • TabularUnified trunk/libavcodec/simple_idct.c

    r256 r263  
    185185{
    186186        int a0, a1, a2, a3, b0, b1, b2, b3;
    187         uint8_t *cm = cropTbl + MAX_NEG_CROP;
     187        uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    188188
    189189        /* XXX: I did that only to give same values as previous code */
    … …  
    257257{
    258258        int a0, a1, a2, a3, b0, b1, b2, b3;
    259         uint8_t *cm = cropTbl + MAX_NEG_CROP;
     259        uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    260260
    261261        /* XXX: I did that only to give same values as previous code */
    … …  
    432432{
    433433    int c0, c1, c2, c3, a0, a1, a2, a3;
    434     const uint8_t *cm = cropTbl + MAX_NEG_CROP;
     434    const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    435435
    436436    a0 = col[8*0];
    … …  
    512512{
    513513    int c0, c1, c2, c3, a0, a1, a2, a3;
    514     const uint8_t *cm = cropTbl + MAX_NEG_CROP;
     514    const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    515515
    516516    a0 = col[8*0];
    … …  
    540540{
    541541    int c0, c1, c2, c3, a0, a1, a2, a3;
    542     //const uint8_t *cm = cropTbl + MAX_NEG_CROP;
     542    //const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    543543
    544544    a0 = row[0];

  • TabularUnified trunk/libavcodec/snow.c

    r261 r263  
    19031903{
    19041904    int s, i, j;
    1905     uint32_t *sq = squareTbl + 256;
     1905    uint32_t *sq = ff_squareTbl + 256;
    19061906
    19071907    s = 0;

  • TabularUnified trunk/libavcodec/svq3.c

    r256 r263  
    148148    const int qmul= svq3_dequant_coeff[qp];
    149149    int i;
    150     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     150    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    151151
    152152    if (dc) {

  • TabularUnified trunk/libavcodec/utils.c

    r262 r263  
    442442{"naq", "normalize adaptive quantization", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_NORMALIZE_AQP, INT_MIN, INT_MAX, V|E, "flags"},
    443443{"ildct", "use interlaced dct", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_INTERLACED_DCT, INT_MIN, INT_MAX, V|E, "flags"},
    444 {"low_delay", "force low delay", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_LOW_DELAY, INT_MIN, INT_MAX, V|D, "flags"},
     444{"low_delay", "force low delay", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_LOW_DELAY, INT_MIN, INT_MAX, V|D|E, "flags"},
    445445{"alt", "enable alternate scantable (mpeg2/mpeg4)", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_ALT_SCAN, INT_MIN, INT_MAX, V|E, "flags"},
    446446{"trell", "use trellis quantization", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_TRELLIS_QUANT, INT_MIN, INT_MAX, V|E, "flags"},

  • TabularUnified trunk/libavcodec/vc1.c

    r257 r263  
    33413341                    s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
    33423342                    if(v->pq >= 9 && v->overlap) {
     3343                        if(v->c_avail)
     3344                            s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? (i&1) : (s->mb_x&1));
    33433345                        if(v->a_avail)
    33443346                            s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? ((i&1)>>1) : (s->mb_y&1));
    3345                         if(v->c_avail)
    3346                             s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? (i&1) : (s->mb_x&1));
    33473347                    }
    33483348                } else if(val) {
    … …  
    34443444                    s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
    34453445                    if(v->pq >= 9 && v->overlap) {
     3446                        if(v->c_avail)
     3447                            s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? (i&1) : (s->mb_x&1));
    34463448                        if(v->a_avail)
    34473449                            s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? ((i&1)>>1) : (s->mb_y&1));
    3448                         if(v->c_avail)
    3449                             s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? (i&1) : (s->mb_x&1));
    34503450                    }
    34513451                } else if(is_coded[i]) {
    … …  
    37133713            vc1_put_block(v, s->block);
    37143714            if(v->pq >= 9 && v->overlap) {
     3715                if(s->mb_x) {
     3716                    s->dsp.vc1_h_overlap(s->dest[0], s->linesize, 0);
     3717                    s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize, 0);
     3718                    if(!(s->flags & CODEC_FLAG_GRAY)) {
     3719                        s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize, s->mb_x&1);
     3720                        s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize, s->mb_x&1);
     3721                    }
     3722                }
     3723                s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize, 1);
     3724                s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize, 1);
    37153725                if(!s->first_slice_line) {
    37163726                    s->dsp.vc1_v_overlap(s->dest[0], s->linesize, 0);
    … …  
    37233733                s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize, 1);
    37243734                s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize, 1);
    3725                 if(s->mb_x) {
    3726                     s->dsp.vc1_h_overlap(s->dest[0], s->linesize, 0);
    3727                     s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize, 0);
    3728                     if(!(s->flags & CODEC_FLAG_GRAY)) {
    3729                         s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize, s->mb_x&1);
    3730                         s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize, s->mb_x&1);
    3731                     }
    3732                 }
    3733                 s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize, 1);
    3734                 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize, 1);
    37353735            }
    37363736
    … …  
    38433843            vc1_put_block(v, s->block);
    38443844            if(overlap) {
     3845                if(s->mb_x) {
     3846                    s->dsp.vc1_h_overlap(s->dest[0], s->linesize, 0);
     3847                    s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize, 0);
     3848                    if(!(s->flags & CODEC_FLAG_GRAY)) {
     3849                        s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize, s->mb_x&1);
     3850                        s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize, s->mb_x&1);
     3851                    }
     3852                }
     3853                s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize, 1);
     3854                s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize, 1);
    38453855                if(!s->first_slice_line) {
    38463856                    s->dsp.vc1_v_overlap(s->dest[0], s->linesize, 0);
    … …  
    38533863                s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize, 1);
    38543864                s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize, 1);
    3855                 if(s->mb_x) {
    3856                     s->dsp.vc1_h_overlap(s->dest[0], s->linesize, 0);
    3857                     s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize, 0);
    3858                     if(!(s->flags & CODEC_FLAG_GRAY)) {
    3859                         s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize, s->mb_x&1);
    3860                         s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize, s->mb_x&1);
    3861                     }
    3862                 }
    3863                 s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize, 1);
    3864                 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize, 1);
    38653865            }
    38663866

  • TabularUnified trunk/libavcodec/vc1data.h

    r256 r263  
    4848
    4949/* pre-computed scales for all bfractions and base=256 */
    50 const int16_t vc1_bfraction_lut[23] = {
     50static const int16_t vc1_bfraction_lut[23] = {
    5151  128 /*1/2*/,  85 /*1/3*/, 170 /*2/3*/,  64 /*1/4*/,
    5252  192 /*3/4*/,  51 /*1/5*/, 102 /*2/5*/,
    … …  
    5959#endif
    6060
    61 const uint8_t vc1_bfraction_bits[23] = {
     61static const uint8_t vc1_bfraction_bits[23] = {
    6262    3, 3, 3, 3,
    6363    3, 3, 3,
    … …  
    6868    7, 7
    6969};
    70 const uint8_t vc1_bfraction_codes[23] = {
     70static const uint8_t vc1_bfraction_codes[23] = {
    7171     0,   1,   2,   3,
    7272     4,   5,   6,

  • TabularUnified trunk/libavcodec/vc1dsp.c

    r256 r263  
    3030
    3131
    32 /** Apply overlap transform to vertical edge
     32/** Apply overlap transform to horizontal edge
    3333*/
    3434static void vc1_v_overlap_c(uint8_t* src, int stride, int rnd)
    … …  
    3636    int i;
    3737    int a, b, c, d;
     38    int d1, d2;
    3839    for(i = 0; i < 8; i++) {
    3940        a = src[-2*stride];
    … …  
    4142        c = src[0];
    4243        d = src[stride];
    43 
    44         src[-2*stride] = clip_uint8((7*a + d + 4 - rnd) >> 3);
    45         src[-stride] = clip_uint8((-a + 7*b + c + d + 3 + rnd) >> 3);
    46         src[0] = clip_uint8((a + b + 7*c - d + 4 - rnd) >> 3);
    47         src[stride] = clip_uint8((a + 7*d + 3 + rnd) >> 3);
     44        d1 = (a - d + 3 + rnd) >> 3;
     45        d2 = (a - d + b - c + 4 - rnd) >> 3;
     46
     47        src[-2*stride] = a - d1;
     48        src[-stride] = b - d2;
     49        src[0] = c + d2;
     50        src[stride] = d + d1;
    4851        src++;
    4952    }
    5053}
    5154
    52 /** Apply overlap transform to horizontal edge
     55/** Apply overlap transform to vertical edge
    5356*/
    5457static void vc1_h_overlap_c(uint8_t* src, int stride, int rnd)
    … …  
    5659    int i;
    5760    int a, b, c, d;
     61    int d1, d2;
    5862    for(i = 0; i < 8; i++) {
    5963        a = src[-2];
    … …  
    6165        c = src[0];
    6266        d = src[1];
    63 
    64         src[-2] = clip_uint8((7*a + d + 4 - rnd) >> 3);
    65         src[-1] = clip_uint8((-a + 7*b + c + d + 3 + rnd) >> 3);
    66         src[0] = clip_uint8((a + b + 7*c - d + 4 - rnd) >> 3);
    67         src[1] = clip_uint8((a + 7*d + 3 + rnd) >> 3);
     67        d1 = (a - d + 3 + rnd) >> 3;
     68        d2 = (a - d + b - c + 4 - rnd) >> 3;
     69
     70        src[-2] = a - d1;
     71        src[-1] = b - d2;
     72        src[0] = c + d2;
     73        src[1] = d + d1;
    6874        src += stride;
    6975    }

  • TabularUnified trunk/libavcodec/vmdav.c

    r256 r263  
    485485            if (s->bits == 16)
    486486                vmdaudio_decode_audio(s, data, buf, 1);
    487             else
     487            else {
    488488                /* copy the data but convert it to signed */
    489                 for (i = 0; i < s->block_align; i++)
    490                     data[i * 2 + 1] = buf[i] + 0x80;
     489                for (i = 0; i < s->block_align; i++){
     490                    *data++ = buf[i] + 0x80;
     491                    *data++ = buf[i] + 0x80;
     492                }
     493            }
    491494        }
    492495    } else {
    … …  
    501504            } else {
    502505                /* copy the data but convert it to signed */
    503                 for (i = 0; i < s->block_align; i++)
    504                     data[i * 2 + 1] = buf[i] + 0x80;
     506                for (i = 0; i < s->block_align; i++){
     507                    *data++ = buf[i] + 0x80;
     508                    *data++ = buf[i] + 0x80;
     509                }
    505510            }
    506511        }
    … …  
    515520{
    516521    VmdAudioContext *s = (VmdAudioContext *)avctx->priv_data;
    517     unsigned int sound_flags;
    518522    unsigned char *output_samples = (unsigned char *)data;
    519523
    520524    /* point to the start of the encoded data */
    521525    unsigned char *p = buf + 16;
    522     unsigned char *p_end = buf + buf_size;
    523526
    524527    if (buf_size < 16)
    … …  
    529532        *data_size = vmdaudio_loadsound(s, output_samples, p, 0);
    530533    } else if (buf[6] == 2) {
    531         /* the chunk contains audio and silence mixed together */
    532         sound_flags = LE_32(p);
     534        /* the chunk may contain audio */
    533535        p += 4;
    534 
    535         /* do something with extrabufs here? */
    536 
    537         while (p < p_end) {
    538             if (sound_flags & 0x01)
    539                 /* silence */
    540                 *data_size += vmdaudio_loadsound(s, output_samples, p, 1);
    541             else {
    542                 /* audio */
    543                 *data_size += vmdaudio_loadsound(s, output_samples, p, 0);
    544                 p += s->block_align;
    545             }
    546             output_samples += (s->block_align * s->bits / 8);
    547             sound_flags >>= 1;
    548         }
     536        *data_size = vmdaudio_loadsound(s, output_samples, p, (buf_size == 16));
     537        output_samples += (s->block_align * s->bits / 8);
    549538    } else if (buf[6] == 3) {
    550539        /* silent chunk */

  • TabularUnified trunk/libavcodec/vorbis.c

    r257 r263  
    14391439        for(partition_count=0;partition_count<ptns_to_read;) {  // SPEC        error
    14401440            if (!pass) {
    1441                 uint_fast32_t inverse_class = inverse[vr->classifications];
     1441                uint_fast32_t inverse_class = ff_inverse[vr->classifications];
    14421442                for(j_times_ptns_to_read=0, j=0;j<ch_used;++j) {
    14431443                    if (!do_not_decode[j]) {

  • TabularUnified trunk/libavcodec/vp3dsp.c

    r256 r263  
    4343{
    4444    int16_t *ip = input;
    45     uint8_t *cm = cropTbl + MAX_NEG_CROP;
     45    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    4646
    4747    int A, B, C, D, Ad, Bd, Cd, Dd, E, F, G, H;

  • TabularUnified trunk/libavcodec/vp6data.h

    r261 r263  
    276276};
    277277
    278 const vp56_tree_t vp6_pcr_tree[] = {
     278static const vp56_tree_t vp6_pcr_tree[] = {
    279279    { 8, 0},
    280280    { 4, 1},

  • TabularUnified trunk/libavcodec/x264.c

    r261 r263  
    6767}
    6868
    69 extern int
     69static int
    7070X264_frame(AVCodecContext *ctx, uint8_t *buf, int bufsize, void *data)
    7171{
    … …  
    131131}
    132132
    133 extern int
     133static int
    134134X264_init(AVCodecContext *avctx)
    135135{

  • TabularUnified trunk/libavcodec/xl.c

    r256 r263  
    3434} VideoXLContext;
    3535
    36 const int xl_table[32] = {
     36static const int xl_table[32] = {
    3737   0,   1,   2,   3,   4,   5,   6,   7,
    3838   8,   9,  12,  15,  20,  25,  34,  46,

  • TabularUnified trunk/libavformat/aiff.c

    r261 r263  
    2424#include "intfloat_readwrite.h"
    2525
    26 const CodecTag codec_aiff_tags[] = {
     26static const CodecTag codec_aiff_tags[] = {
    2727    { CODEC_ID_PCM_S16BE, MKTAG('N','O','N','E') },
    2828    { CODEC_ID_PCM_S8, MKTAG('N','O','N','E') },

  • TabularUnified trunk/libavformat/allformats.c

    r261 r263  
    250250#endif
    251251#ifdef CONFIG_NUT_MUXER
     252#ifdef CONFIG_LIBNUT
    252253    av_register_output_format(&nut_muxer);
     254#endif
    253255#endif
    254256#ifdef CONFIG_NUV_DEMUXER

  • TabularUnified trunk/libavformat/asf.c

    r261 r263  
    2323#include "mpegaudio.h"
    2424#include "asf.h"
     25#include "common.h"
    2526
    2627#undef NDEBUG
    … …  
    108109static void get_str16_nolen(ByteIOContext *pb, int len, char *buf, int buf_size)
    109110{
    110     int c;
    111     char *q;
    112 
    113     q = buf;
    114     while (len > 0) {
    115         c = get_le16(pb);
    116         if ((q - buf) < buf_size - 1)
    117             *q++ = c;
    118         len-=2;
     111    char* q = buf;
     112    len /= 2;
     113    while (len--) {
     114        uint8_t tmp;
     115        PUT_UTF8(get_le16(pb), tmp, if (q - buf < buf_size - 1) *q++ = tmp;)
    119116    }
    120117    *q = '\0';
    … …  
    362359
    363360                        name_len = get_le16(pb);
    364                         name = (char *)av_mallocz(name_len);
    365                         get_str16_nolen(pb, name_len, name, name_len);
     361                        name = (char *)av_malloc(name_len * 2);
     362                        get_str16_nolen(pb, name_len, name, name_len * 2);
    366363                        value_type = get_le16(pb);
    367364                        value_len = get_le16(pb);
    368365                        if ((value_type == 0) || (value_type == 1)) // unicode or byte
    369366                        {
    370                                 value = (char *)av_mallocz(value_len);
    371                                 get_str16_nolen(pb, value_len, value, value_len);
     367                                value = (char *)av_malloc(value_len * 2);
     368                                get_str16_nolen(pb, value_len, value,
     369                                        value_len * 2);
    372370                                if (strcmp(name,"WM/AlbumTitle")==0) { pstrcpy(s->album, sizeof(s->album), value); }
    373371                                av_free(value);

  • TabularUnified trunk/libavformat/avformat.h

    r262 r263  
    3232#define LIBAVFORMAT_IDENT       "Lavf" AV_STRINGIFY(LIBAVFORMAT_VERSION)
    3333
     34#include "config.h"
    3435#include <time.h>
    3536#include <stdio.h>  /* FILE */
    3637#include "avcodec.h"
    37 #include "config.h"
    3838
    3939#include "avio.h"
    … …  
    238238    /**
    239239     * real base frame rate of the stream.
     240     * this is the lowest framerate with which all timestamps can be
     241     * represented accurately (its the least common multiple of all
     242     * framerates in the stream), Note, this value is just a guess!
    240243     * for example if the timebase is 1/90000 and all frames have either
    241244     * approximately 3600 or 1800 timer ticks then r_frame_rate will be 50/1
    … …  
    444447int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags);
    445448void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp);
     449int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ));
    446450
    447451/* media file output */

  • TabularUnified trunk/libavformat/avidec.c

    r262 r263  
    146146                avi->non_interleaved= 1;
    147147            else
    148                 av_add_index_entry(st, pos, ast->cum_len, len, 0, key ? AVINDEX_KEYFRAME : 0);
     148                av_add_index_entry(st, pos, ast->cum_len / FFMAX(1, ast->sample_size), len, 0, key ? AVINDEX_KEYFRAME : 0);
    149149
    150150            if(ast->sample_size)
    151                 ast->cum_len += len / ast->sample_size;
     151                ast->cum_len += len;
    152152            else
    153153                ast->cum_len ++;
    … …  
    217217    AVStream *st;
    218218    AVIStream *ast = NULL;
    219     int xan_video = 0;  /* hack to support Xan A/V */
    220219    char str_track[4];
    221220
    … …  
    307306                av_freep(&s->streams[0]);
    308307                s->nb_streams = 0;
    309                 avi->dv_demux = dv_init_demux(s);
    310                 if (!avi->dv_demux)
    311                     goto fail;
     308                if (ENABLE_DV_DEMUXER) {
     309                    avi->dv_demux = dv_init_demux(s);
     310                    if (!avi->dv_demux)
     311                        goto fail;
     312                }
    312313                s->streams[0]->priv_data = ast;
    313314                url_fskip(pb, 3 * 4);
    … …  
    354355            get_le32(pb); /* quality */
    355356            ast->sample_size = get_le32(pb); /* sample ssize */
     357            ast->cum_len *= FFMAX(1, ast->sample_size);
    356358//            av_log(NULL, AV_LOG_DEBUG, "%d %d %d %d\n", ast->rate, ast->scale, ast->start, ast->sample_size);
    357359
    … …  
    377379                goto fail;
    378380            }
    379             ast->frame_offset= ast->cum_len * FFMAX(ast->sample_size, 1);
     381            ast->frame_offset= ast->cum_len;
    380382            url_fskip(pb, size - 12 * 4);
    381383            break;
    … …  
    430432                    st->codec->codec_tag = tag1;
    431433                    st->codec->codec_id = codec_get_id(codec_bmp_tags, tag1);
    432                     if (st->codec->codec_id == CODEC_ID_XAN_WC4)
    433                         xan_video = 1;
    434434                    st->need_parsing = 2; //only parse headers dont do slower repacketization, this is needed to get the pict type which is needed for generating correct pts
    435435//                    url_fskip(pb, size - 5 * 4);
    … …  
    441441                    if (size%2) /* 2-aligned (fix for Stargate SG-1 - 3x18 - Shades of Grey.avi) */
    442442                        url_fskip(pb, 1);
    443                     /* special case time: To support Xan DPCM, hardcode
    444                      * the format if Xxan is the video codec */
     443                    /* Force parsing as several audio frames can be in
     444                     * one packet. */
    445445                    st->need_parsing = 1;
    446446                    /* ADTS header is in extradata, AAC without header must be stored as exact frames, parser not needed and it will fail */
    447447                    if (st->codec->codec_id == CODEC_ID_AAC && st->codec->extradata_size)
    448448                        st->need_parsing = 0;
    449                     /* force parsing as several audio frames can be in
    450                        one packet */
    451                     if (xan_video)
    452                         st->codec->codec_id = CODEC_ID_XAN_DPCM;
     449                    /* AVI files with Xan DPCM audio (wrongly) declare PCM
     450                     * audio in the header but have Axan as stream_code_tag. */
     451                    if (st->codec->stream_codec_tag == ff_get_fourcc("Axan")){
     452                        st->codec->codec_id  = CODEC_ID_XAN_DPCM;
     453                        st->codec->codec_tag = 0;
     454                    }
    453455                    break;
    454456                default:
    … …  
    526528    void* dstr;
    527529
    528     if (avi->dv_demux) {
     530    if (ENABLE_DV_DEMUXER && avi->dv_demux) {
    529531        size = dv_get_packet(avi->dv_demux, pkt);
    530532        if (size >= 0)
    … …  
    595597        av_get_packet(pb, pkt, size);
    596598
    597         if (avi->dv_demux) {
     599        if (ENABLE_DV_DEMUXER && avi->dv_demux) {
    598600            dstr = pkt->destruct;
    599601            size = dv_produce_packet(avi->dv_demux, pkt,
    … …  
    804806            avi->non_interleaved= 1;
    805807        else
    806             av_add_index_entry(st, pos, ast->cum_len, len, 0, (flags&AVIIF_INDEX) ? AVINDEX_KEYFRAME : 0);
     808            av_add_index_entry(st, pos, ast->cum_len / FFMAX(1, ast->sample_size), len, 0, (flags&AVIIF_INDEX) ? AVINDEX_KEYFRAME : 0);
    807809        if(ast->sample_size)
    808             ast->cum_len += len / ast->sample_size;
     810            ast->cum_len += len;
    809811        else
    810812            ast->cum_len ++;
    … …  
    936938    }
    937939
    938     if (avi->dv_demux)
     940    if (ENABLE_DV_DEMUXER && avi->dv_demux)
    939941        dv_flush_audio_packets(avi->dv_demux);
    940942    /* do the seek */

  • TabularUnified trunk/libavformat/config.h

    r262 r263  
     1
     2#ifndef ARCH_X86
    13#define ARCH_X86
     4#endif
     5
     6#ifndef HAVE_MMX
    27#define HAVE_MMX
     8#endif
    39#define CONFIG_ENCODERS
    410#define CONFIG_DECODERS
    … …  
    915#define CONFIG_MUXERS
    1016#define CONFIG_DEMUXERS
    11 #define CONFIG_FOURXM_DEMUXER
    12 #define CONFIG_ADTS_MUXER
    13 #define CONFIG_AIFF_DEMUXER
    14 #define CONFIG_AIFF_MUXER
    15 #define CONFIG_AMR_DEMUXER
    16 #define CONFIG_AMR_MUXER
    17 #define CONFIG_ASF_DEMUXER
    18 #define CONFIG_ASF_MUXER
    19 #define CONFIG_ASF_STREAM_MUXER
    20 #define CONFIG_AU_DEMUXER
    21 #define CONFIG_AU_MUXER
     17#define CONFIG_MPEGAUDIO_PARSER
     18//#define CONFIG_FOURXM_DEMUXER
     19//#define CONFIG_ADTS_MUXER
     20//#define CONFIG_AIFF_DEMUXER
     21//#define CONFIG_AIFF_MUXER
     22//#define CONFIG_AMR_DEMUXER
     23//#define CONFIG_AMR_MUXER
     24//#define CONFIG_ASF_DEMUXER
     25//#define CONFIG_ASF_MUXER
     26//#define CONFIG_ASF_STREAM_MUXER
     27//#define CONFIG_AU_DEMUXER
     28//#define CONFIG_AU_MUXER
    2229#define CONFIG_AVI_DEMUXER
    2330#define CONFIG_AVI_MUXER
    24 #define CONFIG_CRC_MUXER
    25 #define CONFIG_FRAMECRC_MUXER
    26 #define CONFIG_DAUD_DEMUXER
    27 #define CONFIG_DV_DEMUXER
    28 #define CONFIG_DV_MUXER
    29 #define CONFIG_EA_DEMUXER
    30 #define CONFIG_FFM_DEMUXER
    31 #define CONFIG_FFM_MUXER
    32 #define CONFIG_FLIC_DEMUXER
     31#define ENABLE_DV_DEMUXER 0
     32//#define CONFIG_CRC_MUXER
     33//#define CONFIG_FRAMECRC_MUXER
     34//#define CONFIG_DAUD_DEMUXER
     35//#define CONFIG_DV_DEMUXER
     36//#define CONFIG_DV_MUXER
     37//#define CONFIG_EA_DEMUXER
     38//#define CONFIG_FFM_DEMUXER
     39//#define CONFIG_FFM_MUXER
     40//#define CONFIG_FLIC_DEMUXER
    3341#define CONFIG_FLV_DEMUXER
    3442#define CONFIG_FLV_MUXER
    35 #define CONFIG_GIF_MUXER
    36 #define CONFIG_GIF_DEMUXER
    37 #define CONFIG_IDCIN_DEMUXER
    38 #define CONFIG_ROQ_DEMUXER
    39 #define CONFIG_IMAGE2_DEMUXER
    40 #define CONFIG_IMAGE2PIPE_DEMUXER
    41 #define CONFIG_IMAGE2_MUXER
    42 #define CONFIG_IMAGE_DEMUXER
    43 #define CONFIG_IMAGE_MUXER
    44 #define CONFIG_IPMOVIE_DEMUXER
     43//#define CONFIG_GIF_MUXER
     44//#define CONFIG_GIF_DEMUXER
     45//#define CONFIG_IDCIN_DEMUXER
     46//#define CONFIG_ROQ_DEMUXER
     47//#define CONFIG_IMAGE2_DEMUXER
     48//#define CONFIG_IMAGE2PIPE_DEMUXER
     49//#define CONFIG_IMAGE2_MUXER
     50//#define CONFIG_IMAGE_DEMUXER
     51//#define CONFIG_IMAGE_MUXER
     52//#define CONFIG_IPMOVIE_DEMUXER
    4553#define CONFIG_MATROSKA_DEMUXER
    46 #define CONFIG_MM_DEMUXER
     54//#define CONFIG_MM_DEMUXER
    4755#define CONFIG_MMF_DEMUXER
    48 #define CONFIG_MMF_MUXER
    49 #define CONFIG_MOV_DEMUXER
    50 #define CONFIG_MOV_MUXER
    51 #define CONFIG_TGP_MUXER
    52 #define CONFIG_MP4_MUXER
    53 #define CONFIG_PSP_MUXER
    54 #define CONFIG_TG2_MUXER
    55 #define CONFIG_MP3_DEMUXER
    56 #define CONFIG_MP2_MUXER
    57 #define CONFIG_MP3_MUXER
    58 #define CONFIG_MPEG1SYSTEM_MUXER
    59 #define CONFIG_MPEG1VCD_MUXER
    60 #define CONFIG_MPEG2VOB_MUXER
    61 #define CONFIG_MPEG2SVCD_MUXER
    62 #define CONFIG_MPEG2DVD_MUXER
     56//#define CONFIG_MMF_MUXER
     57//#define CONFIG_MOV_DEMUXER
     58//#define CONFIG_MOV_MUXER
     59//#define CONFIG_TGP_MUXER
     60//#define CONFIG_MP4_MUXER
     61//#define CONFIG_PSP_MUXER
     62//#define CONFIG_TG2_MUXER
     63//#define CONFIG_MP3_DEMUXER
     64//#define CONFIG_MP2_MUXER
     65//#define CONFIG_MP3_MUXER
     66//#define CONFIG_MPEG1SYSTEM_MUXER
     67//#define CONFIG_MPEG1VCD_MUXER
     68//#define CONFIG_MPEG2VOB_MUXER
     69//#define CONFIG_MPEG2SVCD_MUXER
     70//#define CONFIG_MPEG2DVD_MUXER
    6371#define CONFIG_MPEGPS_DEMUXER
    6472#define CONFIG_MPEGTS_DEMUXER
    65 #define CONFIG_MPEGTS_MUXER
    66 #define CONFIG_MPJPEG_MUXER
    67 #define CONFIG_NSV_DEMUXER
    68 #define CONFIG_NUT_DEMUXER
    69 #define CONFIG_NUT_MUXER
    70 #define CONFIG_NUV_DEMUXER
    71 #define CONFIG_OGG_DEMUXER
    72 #define CONFIG_OGG_MUXER
    73 #define CONFIG_STR_DEMUXER
    74 #define CONFIG_SHORTEN_DEMUXER
    75 #define CONFIG_FLAC_DEMUXER
    76 #define CONFIG_FLAC_MUXER
    77 #define CONFIG_AC3_DEMUXER
    78 #define CONFIG_AC3_MUXER
    79 #define CONFIG_DTS_DEMUXER
    80 #define CONFIG_AAC_DEMUXER
    81 #define CONFIG_H261_DEMUXER
    82 #define CONFIG_H261_MUXER
    83 #define CONFIG_H263_DEMUXER
    84 #define CONFIG_H263_MUXER
    85 #define CONFIG_M4V_DEMUXER
    86 #define CONFIG_M4V_MUXER
    87 #define CONFIG_H264_DEMUXER
    88 #define CONFIG_H264_MUXER
     73//#define CONFIG_MPEGTS_MUXER
     74//#define CONFIG_MPJPEG_MUXER
     75//#define CONFIG_NSV_DEMUXER
     76//#define CONFIG_NUT_DEMUXER
     77//#define CONFIG_NUT_MUXER
     78//#define CONFIG_NUV_DEMUXER
     79//#define CONFIG_OGG_DEMUXER
     80//#define CONFIG_OGG_MUXER
     81//#define CONFIG_STR_DEMUXER
     82//#define CONFIG_SHORTEN_DEMUXER
     83//#define CONFIG_FLAC_DEMUXER
     84//#define CONFIG_FLAC_MUXER
     85//#define CONFIG_AC3_DEMUXER
     86//#define CONFIG_AC3_MUXER
     87//#define CONFIG_DTS_DEMUXER
     88//#define CONFIG_AAC_DEMUXER
     89//#define CONFIG_H261_DEMUXER
     90//#define CONFIG_H261_MUXER
     91//#define CONFIG_H263_DEMUXER
     92//#define CONFIG_H263_MUXER
     93//#define CONFIG_M4V_DEMUXER
     94//#define CONFIG_M4V_MUXER
     95//#define CONFIG_H264_DEMUXER
     96//#define CONFIG_H264_MUXER
    8997#define CONFIG_MPEGVIDEO_DEMUXER
    90 #define CONFIG_MPEG1VIDEO_MUXER
    91 #define CONFIG_MPEG2VIDEO_MUXER
    92 #define CONFIG_MJPEG_DEMUXER
    93 #define CONFIG_INGENIENT_DEMUXER
    94 #define CONFIG_MJPEG_MUXER
    95 #define CONFIG_PCM_S16LE_DEMUXER
    96 #define CONFIG_PCM_S16LE_MUXER
    97 #define CONFIG_PCM_S16BE_DEMUXER
    98 #define CONFIG_PCM_S16BE_MUXER
    99 #define CONFIG_PCM_U16LE_DEMUXER
    100 #define CONFIG_PCM_U16LE_MUXER
    101 #define CONFIG_PCM_U16BE_DEMUXER
    102 #define CONFIG_PCM_U16BE_MUXER
    103 #define CONFIG_PCM_S8_DEMUXER
    104 #define CONFIG_PCM_S8_MUXER
    105 #define CONFIG_PCM_U8_DEMUXER
    106 #define CONFIG_PCM_U8_MUXER
    107 #define CONFIG_PCM_MULAW_DEMUXER
    108 #define CONFIG_PCM_MULAW_MUXER
    109 #define CONFIG_PCM_ALAW_DEMUXER
    110 #define CONFIG_PCM_ALAW_MUXER
    111 #define CONFIG_RAWVIDEO_DEMUXER
    112 #define CONFIG_RAWVIDEO_MUXER
    113 #define CONFIG_NULL_MUXER
    114 #define CONFIG_RM_DEMUXER
    115 #define CONFIG_RM_MUXER
    116 #define CONFIG_SEGAFILM_DEMUXER
    117 #define CONFIG_VMD_DEMUXER
    118 #define CONFIG_SMACKER_DEMUXER
    119 #define CONFIG_SOL_DEMUXER
     98//#define CONFIG_MPEG1VIDEO_MUXER
     99//#define CONFIG_MPEG2VIDEO_MUXER
     100//#define CONFIG_MJPEG_DEMUXER
     101//#define CONFIG_INGENIENT_DEMUXER
     102//#define CONFIG_MJPEG_MUXER
     103//#define CONFIG_PCM_S16LE_DEMUXER
     104//#define CONFIG_PCM_S16LE_MUXER
     105//#define CONFIG_PCM_S16BE_DEMUXER
     106//#define CONFIG_PCM_S16BE_MUXER
     107//#define CONFIG_PCM_U16LE_DEMUXER
     108//#define CONFIG_PCM_U16LE_MUXER
     109//#define CONFIG_PCM_U16BE_DEMUXER
     110//#define CONFIG_PCM_U16BE_MUXER
     111//#define CONFIG_PCM_S8_DEMUXER
     112//#define CONFIG_PCM_S8_MUXER
     113//#define CONFIG_PCM_U8_DEMUXER
     114//#define CONFIG_PCM_U8_MUXER
     115//#define CONFIG_PCM_MULAW_DEMUXER
     116//#define CONFIG_PCM_MULAW_MUXER
     117//#define CONFIG_PCM_ALAW_DEMUXER
     118//#define CONFIG_PCM_ALAW_MUXER
     119//#define CONFIG_RAWVIDEO_DEMUXER
     120//#define CONFIG_RAWVIDEO_MUXER
     121//#define CONFIG_NULL_MUXER
     122//#define CONFIG_RM_DEMUXER
     123//#define CONFIG_RM_MUXER
     124//#define CONFIG_SEGAFILM_DEMUXER
     125//#define CONFIG_VMD_DEMUXER
     126//#define CONFIG_SMACKER_DEMUXER
     127//#define CONFIG_SOL_DEMUXER
    120128#define CONFIG_SWF_DEMUXER
    121 #define CONFIG_SWF_MUXER
    122 #define CONFIG_TTA_DEMUXER
    123 #define CONFIG_VOC_DEMUXER
    124 #define CONFIG_VOC_MUXER
    125 #define CONFIG_WAV_DEMUXER
    126 #define CONFIG_WAV_MUXER
    127 #define CONFIG_WC3_DEMUXER
    128 #define CONFIG_WSAUD_DEMUXER
    129 #define CONFIG_WSVQA_DEMUXER
    130 #define CONFIG_YUV4MPEGPIPE_MUXER
    131 #define CONFIG_YUV4MPEGPIPE_DEMUXER
     129//#define CONFIG_SWF_MUXER
     130//#define CONFIG_TTA_DEMUXER
     131//#define CONFIG_VOC_DEMUXER
     132//#define CONFIG_VOC_MUXER
     133//#define CONFIG_WAV_DEMUXER
     134//#define CONFIG_WAV_MUXER
     135//#define CONFIG_WC3_DEMUXER
     136//#define CONFIG_WSAUD_DEMUXER
     137//#define CONFIG_WSVQA_DEMUXER
     138//#define CONFIG_YUV4MPEGPIPE_MUXER
     139//#define CONFIG_YUV4MPEGPIPE_DEMUXER
    132140#define CONFIG_ZLIB
    133141#define FFMPEG_CONFIGURATION

  • TabularUnified trunk/libavformat/framehook.c

    r262 r263  
    2424#include "framehook.h"
    2525
    26 #ifdef CONFIG_HAVE_DLFCN
     26#ifdef HAVE_DLFCN_H
    2727#include <dlfcn.h>
    2828#endif

  • TabularUnified trunk/libavformat/grab.c

    r256 r263  
    761761        pxor_r2r(mm7,mm7);
    762762#else
    763         uint8_t *cm = cropTbl + MAX_NEG_CROP;
     763        uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
    764764#endif
    765765

  • TabularUnified trunk/libavformat/matroska.c

    r262 r263  
    177177  MATROSKA_TRACK_DEFAULT = (1<<1),
    178178  MATROSKA_TRACK_LACING  = (1<<2),
     179  MATROSKA_TRACK_REAL_V  = (1<<4),
    179180  MATROSKA_TRACK_SHIFT   = (1<<16)
    180181} MatroskaTrackFlags;
    … …  
    223224    {"A_DTS"            , CODEC_ID_DTS},
    224225    {"A_VORBIS"         , CODEC_ID_VORBIS},
    225     {"A_AAC/"           , CODEC_ID_AAC},
     226    {"A_AAC"            , CODEC_ID_AAC},
    226227    {"A_WAVPACK4"       , CODEC_ID_WAVPACK},
    227228    {NULL               , CODEC_ID_NONE}
    … …  
    989990                           sizeof(AVPacket *));
    990991        } else {
    991             av_free(matroska->packets);
    992             matroska->packets = NULL;
     992            av_freep(&matroska->packets);
    993993        }
    994994        matroska->num_packets--;
    … …  
    19431943                        if (!(id = ebml_peek_id (matroska,
    19441944                                                 &matroska->level_up)))
    1945                             break;
     1945                            goto finish;
    19461946                        if (id != seek_id) {
    19471947                            av_log(matroska->ctx, AV_LOG_INFO,
    … …  
    19551955                        /* read master + parse */
    19561956                        if ((res = ebml_read_master(matroska, &id)) < 0)
    1957                             break;
     1957                            goto finish;
    19581958                        switch (id) {
    19591959                            case MATROSKA_ID_CUES:
    … …  
    19721972                                break;
    19731973                        }
    1974                         if (res < 0)
    1975                             break;
    19761974
    19771975                    finish:
    … …  
    21972195            uint8_t *extradata = NULL;
    21982196            int extradata_size = 0;
     2197            int extradata_offset = 0;
    21992198            track = matroska->tracks[i];
    22002199
    … …  
    22462245            }
    22472246
    2248             if (codec_id==CODEC_ID_AAC) {
     2247            else if (codec_id == CODEC_ID_AAC && !track->codec_priv_size) {
    22492248                MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *) track;
    22502249                int profile = matroska_aac_profile(track->codec_id);
    … …  
    22662265            }
    22672266
     2267            else if (codec_id == CODEC_ID_RV10 || codec_id == CODEC_ID_RV20 ||
     2268                     codec_id == CODEC_ID_RV30 || codec_id == CODEC_ID_RV40) {
     2269                extradata_offset = 26;
     2270                track->codec_priv_size -= extradata_offset;
     2271                track->flags |= MATROSKA_TRACK_REAL_V;
     2272            }
     2273
    22682274            if (codec_id == CODEC_ID_NONE) {
    22692275                av_log(matroska->ctx, AV_LOG_INFO,
    … …  
    22942300                    return AVERROR_NOMEM;
    22952301                st->codec->extradata_size = track->codec_priv_size;
    2296                 memcpy(st->codec->extradata, track->codec_priv,
     2302                memcpy(st->codec->extradata,track->codec_priv+extradata_offset,
    22972303                       track->codec_priv_size);
    22982304            }
    … …  
    23452351}
    23462352
     2353static inline int
     2354rv_offset(uint8_t *data, int slice, int slices)
     2355{
     2356    return LE_32(data+8*slice+4) + 8*slices;
     2357}
     2358
    23472359static int
    23482360matroska_parse_blockgroup (MatroskaDemuxContext *matroska,
    … …  
    23842396                origdata = data;
    23852397
    2386                 /* first byte(s): blocknum */
     2398                /* first byte(s): tracknum */
    23872399                if ((n = matroska_ebmlnum_uint(data, size, &num)) < 0) {
    23882400                    av_log(matroska->ctx, AV_LOG_ERROR,
    … …  
    24952507
    24962508                if (res == 0) {
     2509                    int real_v = matroska->tracks[track]->flags & MATROSKA_TRACK_REAL_V;
    24972510                    for (n = 0; n < laces; n++) {
    24982511                        uint64_t timecode = AV_NOPTS_VALUE;
    2499 
    2500                         pkt = av_mallocz(sizeof(AVPacket));
    2501                         /* XXX: prevent data copy... */
    2502                         if (av_new_packet(pkt,lace_size[n]) < 0) {
    2503                             res = AVERROR_NOMEM;
    2504                             break;
     2512                        int slice, slices = 1;
     2513
     2514                        if (real_v) {
     2515                            slices = *data++ + 1;
     2516                            lace_size[n]--;
    25052517                        }
    25062518                        if (cluster_time != (uint64_t)-1 && n == 0) {
    … …  
    25102522                        /* FIXME: duration */
    25112523
    2512                         memcpy(pkt->data, data, lace_size[n]);
     2524                        for (slice=0; slice<slices; slice++) {
     2525                            int slice_size, slice_offset = 0;
     2526                            if (real_v)
     2527                                slice_offset = rv_offset(data, slice, slices);
     2528                            if (slice+1 == slices)
     2529                                slice_size = lace_size[n] - slice_offset;
     2530                            else
     2531                                slice_size = rv_offset(data, slice+1, slices) - slice_offset;
     2532                            pkt = av_mallocz(sizeof(AVPacket));
     2533                            /* XXX: prevent data copy... */
     2534                            if (av_new_packet(pkt, slice_size) < 0) {
     2535                                res = AVERROR_NOMEM;
     2536                                n = laces-1;
     2537                                break;
     2538                            }
     2539                            memcpy (pkt->data, data+slice_offset, slice_size);
     2540
     2541                            if (n == 0)
     2542                                pkt->flags = is_keyframe;
     2543                            pkt->stream_index =
     2544                                matroska->tracks[track]->stream_index;
     2545
     2546                            pkt->pts = timecode;
     2547                            pkt->pos = pos;
     2548
     2549                            matroska_queue_packet(matroska, pkt);
     2550                        }
    25132551                        data += lace_size[n];
    2514                         if (n == 0)
    2515                             pkt->flags = is_keyframe;
    2516                         pkt->stream_index =
    2517                             matroska->tracks[track]->stream_index;
    2518 
    2519                         pkt->pts = timecode;
    2520                         pkt->pos= pos;
    2521 
    2522                         matroska_queue_packet(matroska, pkt);
    25232552                    }
    25242553                }

  • TabularUnified trunk/libavformat/mov.c

    r262 r263  
    415415    else if(type == MKTAG('m', '1', 'a', ' '))
    416416        st->codec->codec_id = CODEC_ID_MP2;
     417    else if(type == MKTAG('s', 'u', 'b', 'p')) {
     418        st->codec->codec_type = CODEC_TYPE_SUBTITLE;
     419        st->codec->codec_id = CODEC_ID_DVD_SUBTITLE;
     420    }
    417421    get_be32(pb); /* component  manufacture */
    418422    get_be32(pb); /* component flags */

  • TabularUnified trunk/libavformat/mpegts.c

    r261 r263  
    11331133}
    11341134
    1135 void set_service_cb(void *opaque, int ret)
     1135static void set_service_cb(void *opaque, int ret)
    11361136{
    11371137    MpegTSContext *ts = opaque;

  • TabularUnified trunk/libavformat/mxf.c

    r259 r263  
    372372        bytes_read += size + 4;
    373373        dprintf("tag 0x%04X, size %d\n", tag, size);
    374         if (!size) /* ignore empty tag, needed for some files with empty UMID tag */
     374        if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
     375            av_log(mxf->fc, AV_LOG_ERROR, "local tag 0x%04X with 0 size\n", tag);
    375376            continue;
     377        }
    376378        switch (tag) {
    377379        case 0x3C0A:
    … …  
    676678    /* PictureEssenceCoding */
    677679    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x02,0x02,0x00 }, CODEC_ID_MPEG2VIDEO, Frame }, /* 422P@ML I-Frame */
     680    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x04,0x02,0x00 }, CODEC_ID_MPEG2VIDEO, Frame }, /* 422P@HL I-Frame */
    678681    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x04,0x03,0x00 }, CODEC_ID_MPEG2VIDEO, Frame }, /* 422P@HL Long GoP */
    679682    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x01,0x11,0x00 }, CODEC_ID_MPEG2VIDEO, Frame }, /* MP@ML Long GoP */
    … …  
    894897            st->codec->height = descriptor->height;
    895898            st->codec->bits_per_sample = descriptor->bits_per_sample; /* Uncompressed */
     899            st->need_parsing = 2; /* only parse headers */
    896900        } else if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
    897901            container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, &descriptor->essence_container_ul);

  • TabularUnified trunk/libavformat/os_support.c

    r256 r263  
    22 * Various utilities for ffmpeg system
    33 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
     4 * copyright (c) 2002 Francois Revol
    45 *
    56 * This file is part of FFmpeg.
    … …  
    5455}
    5556
    56 #if !defined(CONFIG_WINCE)
    57 #if !defined(HAVE_LOCALTIME_R)
     57#if !defined(CONFIG_WINCE) && !defined(HAVE_LOCALTIME_R)
    5858struct tm *localtime_r(const time_t *t, struct tm *tp)
    5959{
    … …  
    6666    return tp;
    6767}
    68 #endif /* !defined(HAVE_LOCALTIME_R) */
    69 #endif /* !defined(CONFIG_WINCE) */
     68#endif /* !defined(CONFIG_WINCE) && !defined(HAVE_LOCALTIME_R) */
     69
     70#if !defined(HAVE_INET_ATON) && defined(CONFIG_NETWORK)
     71#include <stdlib.h>
     72#include <strings.h>
     73#include "barpainet.h"
     74
     75int inet_aton (const char * str, struct in_addr * add)
     76{
     77    const char * pch = str;
     78    unsigned int add1 = 0, add2 = 0, add3 = 0, add4 = 0;
     79
     80    add1 = atoi(pch);
     81    pch = strpbrk(pch,".");
     82    if (pch == 0 || ++pch == 0) goto done;
     83    add2 = atoi(pch);
     84    pch = strpbrk(pch,".");
     85    if (pch == 0 || ++pch == 0) goto done;
     86    add3 = atoi(pch);
     87    pch = strpbrk(pch,".");
     88    if (pch == 0 || ++pch == 0) goto done;
     89    add4 = atoi(pch);
     90
     91done:
     92    add->s_addr=(add4<<24)+(add3<<16)+(add2<<8)+add1;
     93
     94    return 1;
     95}
     96#endif /* !defined(HAVE_INET_ATON) && defined(CONFIG_NETWORK) */

  • TabularUnified trunk/libavformat/os_support.h

    r256 r263  
    4848#include <stdlib.h>
    4949static inline int usleep(unsigned int t) { return _sleep2(t / 1000); }
    50 static inline int strcasecmp(const char* s1, const char* s2) { return stricmp(s1,s2); }
     50//static inline int strcasecmp(const char* s1, const char* s2) { return stricmp(s1,s2); }
    5151#endif
    5252

  • TabularUnified trunk/libavformat/riff.c

    r262 r263  
    201201    { CODEC_ID_PCM_S16LE, MKTAG('R', 'A', 'W', 'A') },
    202202    { CODEC_ID_MP3, MKTAG('L', 'A', 'M', 'E') },
     203    { CODEC_ID_MP3, MKTAG('M', 'P', '3', ' ') },
    203204    { 0, 0 },
    204205};

  • TabularUnified trunk/libavformat/rtsp.c

    r262 r263  
    320320    rtp_payload_data_t *rtp_payload_data = &rtsp_st->rtp_payload_data;
    321321
    322     // TODO (Replace with rtsp_next_attr_and_value)
    323322    /* loop on each attribute */
    324     for(;;) {
    325         skip_spaces(&p);
    326         if (*p == '\0')
    327             break;
    328         get_word_sep(attr, sizeof(attr), "=", &p);
    329         if (*p == '=')
    330             p++;
    331         get_word_sep(value, sizeof(value), ";", &p);
    332         if (*p == ';')
    333             p++;
     323    while(rtsp_next_attr_and_value(&p, attr, sizeof(attr), value, sizeof(value)))
     324    {
    334325        /* grab the codec extra_data from the config parameter of the fmtp line */
    335326        sdp_parse_fmtp_config(codec, attr, value);

  • TabularUnified trunk/libavformat/sierravmd.c

    r261 r263  
    4646    int audio_stream_index;
    4747
    48     unsigned int audio_type;
    49     unsigned int audio_samplerate;
    50     unsigned int audio_bits;
    51     unsigned int audio_channels;
    52 
    5348    unsigned int frame_count;
    5449    unsigned int frames_per_block;
    … …  
    5853    int sample_rate;
    5954    int64_t audio_sample_counter;
    60     int audio_frame_divisor;
    61     int audio_block_align;
    6255    int skiphdr;
    6356
    … …  
    7770    /* only return half certainty since this check is a bit sketchy */
    7871    return AVPROBE_SCORE_MAX / 2;
    79 }
    80 
    81 /* This is a support function to determine the duration, in sample
    82  * frames, of a particular audio chunk, taking into account silent
    83  * encodings. */
    84 static int vmd_calculate_audio_duration(unsigned char *audio_chunk,
    85     int audio_chunk_size, int block_align)
    86 {
    87     unsigned char *p = audio_chunk + 16;
    88     unsigned char *p_end = audio_chunk + audio_chunk_size;
    89     int total_samples = 0;
    90     unsigned int sound_flags;
    91 
    92     if (audio_chunk_size < 16)
    93         return 0;
    94     if (audio_chunk_size == block_align + 16)
    95         return block_align;
    96     if (audio_chunk_size == block_align + 17)
    97         return block_align;
    98 
    99     sound_flags = LE_32(p);
    100     p += 4;
    101     while (p < p_end) {
    102         total_samples += block_align;
    103         if ((sound_flags & 0x01) == 0)
    104             p += block_align;
    105         sound_flags >>= 1;
    106     }
    107     av_log(NULL,0,"Got %i samples for size %i map %08X\n", total_samples, audio_chunk_size, LE_32(audio_chunk));
    108 
    109     return total_samples;
    11072}
    11173
    … …  
    11577    VmdDemuxContext *vmd = (VmdDemuxContext *)s->priv_data;
    11678    ByteIOContext *pb = &s->pb;
    117     AVStream *st;
     79    AVStream *st, *vst;
    11880    unsigned int toc_offset;
    11981    unsigned char *raw_frame_table;
    … …  
    12284    int i, j;
    12385    unsigned int total_frames;
    124     int64_t video_pts_inc = 0;
    125     int64_t current_video_pts = 0;
     86    int64_t pts_inc = 1;
     87    int64_t current_video_pts = 0, current_audio_pts = 0;
    12688    unsigned char chunk[BYTES_PER_FRAME_RECORD];
    127     int lastframe = 0;
     89    int num, den;
     90    int sound_buffers;
    12891
    12992    /* fetch the main header, including the 2 header length bytes */
    … …  
    13295        return AVERROR_IO;
    13396
    134     vmd->audio_sample_counter = 0;
    135     vmd->audio_frame_divisor = 1;
    136     vmd->audio_block_align = 1;
    137 
    13897    /* start up the decoders */
    139     st = av_new_stream(s, 0);
    140     if (!st)
     98    vst = av_new_stream(s, 0);
     99    if (!vst)
    141100        return AVERROR_NOMEM;
    142     av_set_pts_info(st, 33, 1, 90000);
    143     vmd->video_stream_index = st->index;
    144     st->codec->codec_type = CODEC_TYPE_VIDEO;
    145     st->codec->codec_id = CODEC_ID_VMDVIDEO;
    146     st->codec->codec_tag = 0;  /* no fourcc */
    147     st->codec->width = LE_16(&vmd->vmd_header[12]);
    148     st->codec->height = LE_16(&vmd->vmd_header[14]);
    149     st->codec->time_base.num = 1;
    150     st->codec->time_base.den = 10;
    151     st->codec->extradata_size = VMD_HEADER_SIZE;
    152     st->codec->extradata = av_mallocz(VMD_HEADER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
    153     memcpy(st->codec->extradata, vmd->vmd_header, VMD_HEADER_SIZE);
     101    av_set_pts_info(vst, 33, 1, 10);
     102    vmd->video_stream_index = vst->index;
     103    vst->codec->codec_type = CODEC_TYPE_VIDEO;
     104    vst->codec->codec_id = CODEC_ID_VMDVIDEO;
     105    vst->codec->codec_tag = 0;  /* no fourcc */
     106    vst->codec->width = LE_16(&vmd->vmd_header[12]);
     107    vst->codec->height = LE_16(&vmd->vmd_header[14]);
     108    vst->codec->extradata_size = VMD_HEADER_SIZE;
     109    vst->codec->extradata = av_mallocz(VMD_HEADER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
     110    memcpy(vst->codec->extradata, vmd->vmd_header, VMD_HEADER_SIZE);
    154111
    155112    /* if sample rate is 0, assume no audio */
    … …  
    159116        if (!st)
    160117            return AVERROR_NOMEM;
    161         av_set_pts_info(st, 33, 1, 90000);
    162118        vmd->audio_stream_index = st->index;
    163119        st->codec->codec_type = CODEC_TYPE_AUDIO;
    164120        st->codec->codec_id = CODEC_ID_VMDAUDIO;
    165121        st->codec->codec_tag = 0;  /* no fourcc */
    166         st->codec->channels = vmd->audio_channels = (vmd->vmd_header[811] & 0x80) ? 2 : 1;
     122        st->codec->channels = (vmd->vmd_header[811] & 0x80) ? 2 : 1;
    167123        st->codec->sample_rate = vmd->sample_rate;
    168         st->codec->block_align = vmd->audio_block_align =
    169             LE_16(&vmd->vmd_header[806]);
     124        st->codec->block_align = LE_16(&vmd->vmd_header[806]);
    170125        if (st->codec->block_align & 0x8000) {
    171126            st->codec->bits_per_sample = 16;
    172127            st->codec->block_align = -(st->codec->block_align - 0x10000);
    173             vmd->audio_block_align = -(vmd->audio_block_align - 0x10000);
    174128        } else {
    175129            st->codec->bits_per_sample = 8;
    … …  
    178132            st->codec->bits_per_sample * st->codec->channels;
    179133
    180         /* for calculating pts */
    181         vmd->audio_frame_divisor = st->codec->channels;
    182 
    183         video_pts_inc = 90000;
    184         video_pts_inc *= st->codec->block_align;
    185         video_pts_inc /= st->codec->sample_rate;
    186         video_pts_inc /= st->codec->channels;
    187     } else {
    188         /* if no audio, assume 10 frames/second */
    189         video_pts_inc = 90000 / 10;
     134        /* calculate pts */
     135        num = st->codec->block_align;
     136        den = st->codec->sample_rate * st->codec->channels;
     137        av_reduce(&den, &num, den, num, (1UL<<31)-1);
     138        av_set_pts_info(vst, 33, num, den);
     139        av_set_pts_info(st, 33, num, den);
     140        pts_inc = num;
    190141    }
    191142
    … …  
    197148    raw_frame_table = NULL;
    198149    vmd->frame_table = NULL;
     150    sound_buffers = LE_16(&vmd->vmd_header[808]);
    199151    raw_frame_table_size = vmd->frame_count * 6;
    200152    raw_frame_table = av_malloc(raw_frame_table_size);
    … …  
    203155        return -1;
    204156    }
    205     vmd->frame_table = av_malloc(vmd->frame_count * vmd->frames_per_block * sizeof(vmd_frame_t));
     157    vmd->frame_table = av_malloc((vmd->frame_count * vmd->frames_per_block + sound_buffers) * sizeof(vmd_frame_t));
    206158    if (!raw_frame_table || !vmd->frame_table) {
    207159        av_free(raw_frame_table);
    … …  
    233185            switch(type) {
    234186            case 1: /* Audio Chunk */
    235                 vmd->frame_table[total_frames].frame_offset = current_offset;
    236                 vmd->frame_table[total_frames].stream_index = vmd->audio_stream_index;
    237                 vmd->frame_table[total_frames].frame_size = size;
    238                 memcpy(vmd->frame_table[total_frames].frame_record, chunk, BYTES_PER_FRAME_RECORD);
    239                 total_frames++;
     187                /* first audio chunk contains several audio buffers */
     188                if(current_audio_pts){
     189                    vmd->frame_table[total_frames].frame_offset = current_offset;
     190                    vmd->frame_table[total_frames].stream_index = vmd->audio_stream_index;
     191                    vmd->frame_table[total_frames].frame_size = size;
     192                    memcpy(vmd->frame_table[total_frames].frame_record, chunk, BYTES_PER_FRAME_RECORD);
     193                    vmd->frame_table[total_frames].pts = current_audio_pts;
     194                    total_frames++;
     195                    current_audio_pts += pts_inc;
     196                }else{
     197                    uint32_t flags;
     198                    int k;
     199                    int noff;
     200                    int64_t pos;
     201
     202                    pos = url_ftell(pb);
     203                    url_fseek(pb, current_offset, SEEK_SET);
     204                    flags = get_le32(pb);
     205                    noff = 4;
     206                    url_fseek(pb, pos, SEEK_SET);
     207                    av_log(s, AV_LOG_DEBUG, "Sound mapping = %08X (%i bufs)\n", flags, sound_buffers);
     208                    for(k = 0; k < sound_buffers - 1; k++){
     209                        if(flags & 1) { /* silent block */
     210                            vmd->frame_table[total_frames].frame_size = 0;
     211                        }else{
     212                            vmd->frame_table[total_frames].frame_size = st->codec->block_align + (st->codec->block_align & 1);
     213                        }
     214                        noff += vmd->frame_table[total_frames].frame_size;
     215                        vmd->frame_table[total_frames].frame_offset = current_offset + noff;
     216                        vmd->frame_table[total_frames].stream_index = vmd->audio_stream_index;
     217                        memcpy(vmd->frame_table[total_frames].frame_record, chunk, BYTES_PER_FRAME_RECORD);
     218                        vmd->frame_table[total_frames].pts = current_audio_pts;
     219                        total_frames++;
     220                        current_audio_pts += pts_inc;
     221                        flags >>= 1;
     222                    }
     223                }
    240224                break;
    241225            case 2: /* Video Chunk */
    242226                vmd->frame_table[total_frames].frame_offset = current_offset;
     227                vmd->frame_table[total_frames].stream_index = vmd->video_stream_index;
    243228                vmd->frame_table[total_frames].frame_size = size;
    244                 vmd->frame_table[total_frames].stream_index = vmd->video_stream_index;
    245229                memcpy(vmd->frame_table[total_frames].frame_record, chunk, BYTES_PER_FRAME_RECORD);
    246230                vmd->frame_table[total_frames].pts = current_video_pts;
    247                 if (lastframe) {
    248                     vmd->frame_table[lastframe].pts = current_video_pts - video_pts_inc;
    249                 }
    250                 lastframe = total_frames;
    251231                total_frames++;
    252232                break;
    … …  
    254234            current_offset += size;
    255235        }
    256         current_video_pts += video_pts_inc;
     236        current_video_pts += pts_inc;
    257237    }
    258238
    … …  
    292272    }
    293273    pkt->stream_index = frame->stream_index;
    294     if (frame->frame_record[0] == 0x02)
    295         pkt->pts = frame->pts;
    296     else {
    297         pkt->pts = vmd->audio_sample_counter;
    298         pkt->pts *= 90000;
    299         pkt->pts /= vmd->sample_rate;
    300         pkt->pts /= vmd->audio_channels;
    301         vmd->audio_sample_counter += vmd_calculate_audio_duration(
    302             pkt->data, pkt->size, vmd->audio_block_align);
    303 
    304     }
    305     av_log(NULL, AV_LOG_INFO, " dispatching %s frame with %d bytes and pts %"PRId64" (%0.1f sec)\n",
     274    pkt->pts = frame->pts;
     275    av_log(NULL, AV_LOG_INFO, " dispatching %s frame with %d bytes and pts %"PRId64"\n",
    306276            (frame->frame_record[0] == 0x02) ? "video" : "audio",
    307277            frame->frame_size + BYTES_PER_FRAME_RECORD,
    308             pkt->pts, (float)(pkt->pts / 90000.0));
     278            pkt->pts);
    309279
    310280    vmd->current_frame++;

  • TabularUnified trunk/libavformat/swf.c

    r261 r263  
    451451        default:
    452452            /* not supported */
     453            av_log(s, AV_LOG_ERROR, "swf doesnt support that sample rate, choose from (44100, 22050, 11025)\n");
    453454            av_free(swf->audio_fifo);
    454455            av_free(swf);

  • TabularUnified trunk/libavformat/utils.c

    r262 r263  
    276276{
    277277    AVInputFormat *fmt1, *fmt;
    278     int score, score_max, i=0;
     278    int score, score_max;
    279279
    280280    fmt = NULL;
    … …  
    283283        if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
    284284            continue;
    285         i++;
    286285        score = 0;
    287286        if (fmt1->read_probe) {
    … …  
    406405        goto fail;
    407406
    408     if (pb)
     407    if (pb && !ic->data_offset)
    409408        ic->data_offset = url_ftell(&ic->pb);
    410409
    … …  
    11651164    int64_t pos_min, pos_max, pos, pos_limit;
    11661165    int64_t ts_min, ts_max, ts;
    1167     int64_t start_pos, filesize;
    1168     int index, no_change;
     1166    int index;
    11691167    AVStream *st;
    11701168
    … …  
    12141212    }
    12151213
     1214    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
     1215    if(pos<0)
     1216        return -1;
     1217
     1218    /* do the seek */
     1219    url_fseek(&s->pb, pos, SEEK_SET);
     1220
     1221    av_update_cur_dts(s, st, ts);
     1222
     1223    return 0;
     1224}
     1225
     1226/**
     1227 * Does a binary search using read_timestamp().
     1228 * this isnt supposed to be called directly by a user application, but by demuxers
     1229 * @param target_ts target timestamp in the time base of the given stream
     1230 * @param stream_index stream number
     1231 */
     1232int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )){
     1233    int64_t pos, ts;
     1234    int64_t start_pos, filesize;
     1235    int no_change;
     1236
     1237#ifdef DEBUG_SEEK
     1238    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
     1239#endif
     1240
    12161241    if(ts_min == AV_NOPTS_VALUE){
    12171242        pos_min = s->data_offset;
    1218         ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
     1243        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
    12191244        if (ts_min == AV_NOPTS_VALUE)
    12201245            return -1;
    … …  
    12271252        do{
    12281253            pos_max -= step;
    1229             ts_max = avif->read_timestamp(s, stream_index, &pos_max, pos_max + step);
     1254            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
    12301255            step += step;
    12311256        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
    … …  
    12351260        for(;;){
    12361261            int64_t tmp_pos= pos_max + 1;
    1237             int64_t tmp_ts= avif->read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
     1262            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
    12381263            if(tmp_ts == AV_NOPTS_VALUE)
    12391264                break;
    … …  
    12791304        start_pos= pos;
    12801305
    1281         ts = avif->read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
     1306        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
    12821307        if(pos == pos_max)
    12831308            no_change++;
    … …  
    13031328#ifdef DEBUG_SEEK
    13041329    pos_min = pos;
    1305     ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
     1330    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
    13061331    pos_min++;
    1307     ts_max = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
     1332    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
    13081333    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
    13091334           pos, ts_min, target_ts, ts_max);
    13101335#endif
    1311     /* do the seek */
    1312     url_fseek(&s->pb, pos, SEEK_SET);
    1313 
    1314     av_update_cur_dts(s, st, ts);
    1315 
    1316     return 0;
     1336    *ts_ret= ts;
     1337    return pos;
    13171338}
    13181339

  • TabularUnified trunk/libavutil/avutil.h

    r261 r263  
    3535#define AV_TOSTRING(s) #s
    3636
    37 #define LIBAVUTIL_VERSION_INT   ((49<<16)+(0<<8)+2)
    38 #define LIBAVUTIL_VERSION       49.0.2
     37#define LIBAVUTIL_VERSION_INT   ((49<<16)+(1<<8)+0)
     38#define LIBAVUTIL_VERSION       49.1.0
    3939#define LIBAVUTIL_BUILD         LIBAVUTIL_VERSION_INT
    4040
    … …  
    7979    PIX_FMT_YUV411P,   ///< Planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
    8080    PIX_FMT_RGB565,    ///< Packed RGB 5:6:5, 16bpp, (msb)   5R 6G 5B(lsb), in cpu endianness
    81     PIX_FMT_RGB555,    ///< Packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), in cpu endianness most significant bit to 1
     81    PIX_FMT_RGB555,    ///< Packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), in cpu endianness most significant bit to 0
    8282    PIX_FMT_GRAY8,     ///<        Y        ,  8bpp
    8383    PIX_FMT_MONOWHITE, ///<        Y        ,  1bpp, 1 is white

  • TabularUnified trunk/libavutil/common.h

    r262 r263  
    8585#endif
    8686
    87 #ifndef EMULATE_INTTYPES
    8887#   include <inttypes.h>
    89 #else
    90     typedef signed char  int8_t;
    91     typedef signed short int16_t;
    92     typedef signed int   int32_t;
    93     typedef unsigned char  uint8_t;
    94     typedef unsigned short uint16_t;
    95     typedef unsigned int   uint32_t;
    96     typedef signed long long   int64_t;
    97     typedef unsigned long long uint64_t;
    98 #endif /* EMULATE_INTTYPES */
    9988
    10089#ifndef PRId64
    … …  
    156145#ifndef UINT64_MAX
    157146#define UINT64_MAX uint64_t_C(0xFFFFFFFFFFFFFFFF)
    158 #endif
    159 
    160 #ifdef EMULATE_FAST_INT
    161 typedef signed char int_fast8_t;
    162 typedef signed int  int_fast16_t;
    163 typedef signed int  int_fast32_t;
    164 typedef unsigned char uint_fast8_t;
    165 typedef unsigned int  uint_fast16_t;
    166 typedef unsigned int  uint_fast32_t;
    167 typedef uint64_t      uint_fast64_t;
    168147#endif
    169148
    … …  
    330309 * \param GET_BYTE gets utf-8 encoded bytes from any proper source. It can be
    331310 * a function or a statement whose return value or evaluated value is of type
    332  * uint8_t. It will be execuded up to 4 times.
     311 * uint8_t. It will be executed up to 4 times for values in the valid utf-8 range,
     312 * and up to 7 times in the general case.
    333313 * \param ERROR action that should be taken when an invalid utf-8 byte is returned
    334314 * from GET_BYTE. It should be a statement that jumps out of the macro,
    … …  
    362342 * It could be a function or a statement, and uses tmp as the input byte.
    363343 * For example, PUT_BYTE could be "*output++ = tmp;" PUT_BYTE will be
    364  * executed up to 4 times, depending on the length of the converted
     344 * executed up to 4 times for values in the valid utf-8 range and up to
     345 * 7 times in the general case, depending on the length of the converted
    365346 * unicode character.
    366347 */

  • TabularUnified trunk/libavutil/config.h

    r261 r263  
    1616//#define HAVE_BUILTIN_VECTOR ///????
    1717#define HAVE_LRINTF
     18#define HAVE_THREADS
    1819#define CONFIG_GPL
    1920#define CONFIG_ENCODERS

  • TabularUnified trunk/libavutil/internal.h

    r261 r263  
    3131#endif
    3232
    33 #    ifndef ENODATA
    34 #        define ENODATA  61
    35 #    endif
     33#ifndef ENODATA
     34#    define ENODATA  61
     35#endif
    3636
    3737#include "bswap.h"
    … …  
    3939#include <stddef.h>
    4040#ifndef offsetof
    41 # define offsetof(T,F) ((unsigned int)((char *)&((T *)0)->F))
     41#    define offsetof(T,F) ((unsigned int)((char *)&((T *)0)->F))
    4242#endif
    4343
    … …  
    5252#    ifdef CONFIG_WINCE
    5353#        define perror(a)
     54#        define abort()
    5455#    endif
    5556
    … …  
    5859/* OS/2 EMX */
    5960
    60 #include <float.h>
     61#    include <float.h>
    6162
    6263#endif /* !__MINGW32__ && CONFIG_OS2 */
    6364
    64 #    ifdef USE_FASTMEMCPY
    65 #        include "libvo/fastmemcpy.h"
    66 #    endif
     65#ifdef USE_FASTMEMCPY
     66#    include "libvo/fastmemcpy.h"
     67#endif
    6768
    6869// Use rip-relative addressing if compiling PIC code on x86-64.
    69 #    if defined(__MINGW32__) || defined(__CYGWIN__) || \
    70         defined(__OS2__) || (defined (__OpenBSD__) && !defined(__ELF__))
    71 #        if defined(ARCH_X86_64) && defined(PIC)
    72 #            define MANGLE(a) "_" #a"(%%rip)"
    73 #        else
    74 #            define MANGLE(a) "_" #a
    75 #        endif
     70#if defined(__MINGW32__) || defined(__CYGWIN__) || \
     71    defined(__OS2__) || (defined (__OpenBSD__) && !defined(__ELF__))
     72#    if defined(ARCH_X86_64) && defined(PIC)
     73#        define MANGLE(a) "_" #a"(%%rip)"
    7674#    else
    77 #        if defined(ARCH_X86_64) && defined(PIC)
    78 #            define MANGLE(a) #a"(%%rip)"
    79 #        elif defined(CONFIG_DARWIN)
    80 #            define MANGLE(a) "_" #a
    81 #        else
    82 #            define MANGLE(a) #a
    83 #        endif
    84 #    endif
     75#        define MANGLE(a) "_" #a
     76#    endif
     77#else
     78#    if defined(ARCH_X86_64) && defined(PIC)
     79#        define MANGLE(a) #a"(%%rip)"
     80#    elif defined(CONFIG_DARWIN)
     81#        define MANGLE(a) "_" #a
     82#    else
     83#        define MANGLE(a) #a
     84#    endif
     85#endif
    8586
    8687/* debug stuff */
    8788
    88 #    if !defined(DEBUG) && !defined(NDEBUG)
    89 #        define NDEBUG
    90 #    endif
    91 #    include <assert.h>
     89#if !defined(DEBUG) && !defined(NDEBUG)
     90#    define NDEBUG
     91#endif
     92#include <assert.h>
    9293
    9394/* dprintf macros */
    94 #    ifdef DEBUG
    95 #        define dprintf(fmt,...) av_log(NULL, AV_LOG_DEBUG, fmt, __VA_ARGS__)
    96 #    else
    97 #        define dprintf(fmt,...)
    98 #    endif
    99 
    100 #    ifdef CONFIG_WINCE
    101 #            define abort()
    102 #    endif
    103 
    104 #    define av_abort()      do { av_log(NULL, AV_LOG_ERROR, "Abort at %s:%d\n", __FILE__, __LINE__); abort(); } while (0)
    105 
    106 extern const uint32_t inverse[256];
     95#ifdef DEBUG
     96#    define dprintf(fmt,...) av_log(NULL, AV_LOG_DEBUG, fmt, __VA_ARGS__)
     97#else
     98#    define dprintf(fmt,...)
     99#endif
     100
     101#define av_abort()      do { av_log(NULL, AV_LOG_ERROR, "Abort at %s:%d\n", __FILE__, __LINE__); abort(); } while (0)
     102
     103/* math */
     104
     105extern const uint32_t ff_inverse[256];
    107106
    108107#if defined(ARCH_X86)
    … …  
    113112            "mull %3"\
    114113            :"=d"(ret),"=a"(dmy)\
    115             :"1"(a),"g"(inverse[b])\
     114            :"1"(a),"g"(ff_inverse[b])\
    116115            );\
    117116        ret;\
    … …  
    124123            "umull %1, %0, %2, %3"\
    125124            :"=&r"(ret),"=&r"(dmy)\
    126             :"r"(a),"r"(inverse[b])\
     125            :"r"(a),"r"(ff_inverse[b])\
    127126            );\
    128127        ret;\
    129128    })
    130129#elif defined(CONFIG_FASTDIV)
    131 #    define FASTDIV(a,b)   ((uint32_t)((((uint64_t)a)*inverse[b])>>32))
     130#    define FASTDIV(a,b)   ((uint32_t)((((uint64_t)a)*ff_inverse[b])>>32))
    132131#else
    133132#    define FASTDIV(a,b)   ((a)/(b))
    134133#endif
    135134
    136 /* math */
    137135extern FF_IMPORT_ATTR const uint8_t ff_sqrt_tab[128];
    138136

  • TabularUnified trunk/libavutil/log.h

    r256 r263  
    3434                                        Needed because av_log is in libavcodec and has no visibility
    3535                                        of AVIn/OutputFormat */
    36     struct AVOption *option;
     36    const struct AVOption *option;
    3737};
    3838

  • TabularUnified trunk/libavutil/mem.c

    r256 r263  
    4848{
    4949    void *ptr;
    50 #ifdef MEMALIGN_HACK
     50#ifdef CONFIG_MEMALIGN_HACK
    5151    long diff;
    5252#endif
    … …  
    5656        return NULL;
    5757
    58 #ifdef MEMALIGN_HACK
     58#ifdef CONFIG_MEMALIGN_HACK
    5959    ptr = malloc(size+16);
    6060    if(!ptr)
    … …  
    104104void *av_realloc(void *ptr, unsigned int size)
    105105{
    106 #ifdef MEMALIGN_HACK
     106#ifdef CONFIG_MEMALIGN_HACK
    107107    int diff;
    108108#endif
    … …  
    112112        return NULL;
    113113
    114 #ifdef MEMALIGN_HACK
     114#ifdef CONFIG_MEMALIGN_HACK
    115115    //FIXME this isn't aligned correctly, though it probably isn't needed
    116116    if(!ptr) return av_malloc(size);
    … …  
    131131    /* XXX: this test should not be needed on most libcs */
    132132    if (ptr)
    133 #ifdef MEMALIGN_HACK
     133#ifdef CONFIG_MEMALIGN_HACK
    134134        free(ptr - ((char*)ptr)[-1]);
    135135#else

  • TabularUnified trunk/libmpdemux/asfheader.c

    r247 r263  
    248248int read_asf_header(demuxer_t *demuxer,struct asf_priv* asf){
    249249    int hdr_len = asf->header.objh.size - sizeof(asf->header);
     250    int hdr_skip = 0;
    250251    char *hdr = NULL;
    251252    char guid_buffer[16];
    … …  
    268269
    269270    if (hdr_len > 1024 * 1024) {
    270         dprintf("FATAL: header size bigger than 1MB (%d)!\n"
     271        dprintf("header size bigger than 1MB (%d)!\n"
    271272               "Please contact authors, and upload/send this file.\n",
    272                hdr_len);
    273         return 0;
     273                hdr_len);
     274        hdr_skip = hdr_len - 1024 * 1024;
     275        hdr_len = 1024 * 1024;
    274276    }
    275277    hdr = malloc(hdr_len);
    … …  
    279281    }
    280282    stream_read(demuxer->stream, hdr, hdr_len);
     283    if (hdr_skip)
     284        stream_skip(demuxer->stream, hdr_skip);
    281285    if (stream_eof(demuxer->stream)) {
    282286        dprintf("EOF while reading asf header, broken/incomplete file?\n");

  • TabularUnified trunk/libmpdemux/demux_audio.c

    r261 r263  
    154154};
    155155
    156 extern void free_sh_audio(sh_audio_t* sh);
    157156extern void print_wave_header(WAVEFORMATEX *h);
    158157
    … …  
    543542            if (tmp_srate > 2)
    544543            {
    545                 free_sh_audio(sh_audio);
    546544                return 0;
    547545            }
    … …  
    10391037    "Audio only files",
    10401038    DEMUXER_TYPE_AUDIO,
    1041     1, // unsafe autodetect
     1039    0, // unsafe autodetect
    10421040    demux_audio_open,
    10431041    demux_audio_fill_buffer,

  • TabularUnified trunk/libmpdemux/demux_lavf.c

    r262 r263  
    108108const CodecTag mp_wav_tags[] = {
    109109    { CODEC_ID_ADPCM_4XM, MKTAG('4', 'X', 'M', 'A')},
     110    { CODEC_ID_ADPCM_EA,          MKTAG('A', 'D', 'E', 'A')},
     111    { CODEC_ID_ADPCM_IMA_WS,  MKTAG('A', 'I', 'W', 'S')},
     112    { CODEC_ID_INTERPLAY_DPCM,MKTAG('I', 'N', 'P', 'A')},
     113    { CODEC_ID_DSICINAUDIO,   MKTAG('D', 'C', 'I', 'A')},
    110114    { CODEC_ID_PCM_S24BE, MKTAG('i', 'n', '2', '4')},
    111115    { CODEC_ID_PCM_S8,    MKTAG('t', 'w', 'o', 's')},
     116    { CODEC_ID_ROQ_DPCM,      MKTAG('R', 'o', 'Q', 'A')},
     117    { CODEC_ID_SHORTEN,   MKTAG('s', 'h', 'r', 'n')},
    112118    { CODEC_ID_WAVPACK,   MKTAG('W', 'V', 'P', 'K')},
     119    { CODEC_ID_XAN_DPCM,          MKTAG('A', 'x', 'a', 'n')},
    113120    { CODEC_ID_TTA,       MKTAG('T', 'T', 'A', '1')},
    114     { CODEC_ID_SHORTEN,   MKTAG('s', 'h', 'r', 'n')},
    115121    { 0, 0 },
    116122};
    117123
    118124const CodecTag mp_bmp_tags[] = {
    119     { CODEC_ID_XAN_WC3, MKTAG('W', 'C', '3', 'V')},
     125    { CODEC_ID_DSICINVIDEO,       MKTAG('D', 'C', 'I', 'V')},
     126    { CODEC_ID_FLIC,              MKTAG('F', 'L', 'I', 'C')},
     127    { CODEC_ID_IDCIN,             MKTAG('I', 'D', 'C', 'I')},
     128    { CODEC_ID_INTERPLAY_VIDEO,   MKTAG('I', 'N', 'P', 'V')},
     129    { CODEC_ID_ROQ,               MKTAG('R', 'o', 'Q', 'V')},
     130    { CODEC_ID_TIERTEXSEQVIDEO,   MKTAG('T', 'S', 'E', 'Q')},
     131    { CODEC_ID_VMDVIDEO,   MKTAG('V', 'M', 'D', 'V')},
     132    { CODEC_ID_WS_VQA,            MKTAG('V', 'Q', 'A', 'V')},
     133    { CODEC_ID_XAN_WC3,           MKTAG('W', 'C', '3', 'V')},
    120134    { 0, 0 },
    121135};
    … …  
    563577    "supports many formats, requires libavformat",
    564578    DEMUXER_TYPE_LAVF,
    565     0, // Check after other demuxer
     579    1, // Check after other demuxer
    566580    lavf_check_file,
    567581    demux_lavf_fill_buffer,

  • TabularUnified trunk/libmpdemux/demux_mkv.c

    r257 r263  
    77 */
    88
     9
    910#include <stdlib.h>
    1011#include <stdio.h>
    1112#include <ctype.h>
     13#include <inttypes.h>
    1214
    1315#include "stream.h"
    … …  
    1921
    2022#include "subreader.h"
    21 //#include "libvo/sub.h"
     23
     24int vo_osd_changed(int new_value);
     25#define OSDTYPE_OSD 1
     26#define OSDTYPE_SUBTITLE 2
     27#define OSDTYPE_PROGBAR 3
     28#define OSDTYPE_SPU 4
     29
     30extern subtitle* vo_sub;
    2231
    2332#ifdef USE_QTX_CODECS
    … …  
    5665static int atrc_fl2bps[ATRC_FLAVORS] = {8269, 11714, 13092, 16538, 18260, 22050, 33075, 44100};
    5766static int cook_fl2bps[COOK_FLAVORS] = {1000, 1378, 2024, 2584, 4005, 5513, 8010, 4005, 750, 2498,
    58 4048, 5513, 8010, 11973, 8010, 2584, 4005, 2067, 2584, 2584,
    59 4005, 4005, 5513, 5513, 8010, 12059, 1550, 8010, 12059, 5513,
    60 12016, 16408, 22911, 33506};
    61 
    62 int vo_osd_changed(int new_value);
    63 #define OSDTYPE_OSD 1
    64 #define OSDTYPE_SUBTITLE 2
    65 #define OSDTYPE_PROGBAR 3
    66 #define OSDTYPE_SPU 4
    67 
    68 #include "subreader.h"
    69 //static subtitle ogg_sub;
    70 extern subtitle* vo_sub;
    71 static float clear_sub;
     67                                        4048, 5513, 8010, 11973, 8010, 2584, 4005, 2067, 2584, 2584,
     68                                        4005, 4005, 5513, 5513, 8010, 12059, 1550, 8010, 12059, 5513,
     69                                        12016, 16408, 22911, 33506};
    7270
    7371typedef struct
    7472{
    75     uint32_t order, type, scope;
    76     uint32_t comp_algo;
    77     uint8_t *comp_settings;
    78     int comp_settings_len;
     73  uint32_t order, type, scope;
     74  uint32_t comp_algo;
     75  uint8_t *comp_settings;
     76  int comp_settings_len;
    7977} mkv_content_encoding_t;
    8078
    8179typedef struct mkv_track
    8280{
    83     int tnum;
    84     char *name;
    85 
    86     char *codec_id;
    87     int ms_compat;
    88     char *language;
    89 
    90     int type;
    91 
    92     uint32_t v_width, v_height, v_dwidth, v_dheight;
    93     float v_frate;
    94 
    95     uint32_t a_formattag;
    96     uint32_t a_channels, a_bps;
    97     float a_sfreq;
    98 
    99     float default_duration;
    100 
    101     int default_track;
    102 
    103     void *private_data;
    104     unsigned int private_size;
    105 
    106     /* stuff for realmedia */
    107     int realmedia;
    108     int rv_kf_base, rv_kf_pts;
    109     float rv_pts;  /* previous video timestamp */
    110     float ra_pts;  /* previous audio timestamp */
    111 
    112     /** realaudio descrambling */
    113     int sub_packet_size; ///< sub packet size, per stream
    114     int sub_packet_h; ///< number of coded frames per block
    115     int coded_framesize; ///< coded frame size, per stream
    116     int audiopk_size; ///< audio packet size
    117     unsigned char *audio_buf; ///< place to store reordered audio data
    118     float *audio_timestamp; ///< timestamp for each audio packet
    119     int sub_packet_cnt; ///< number of subpacket already received
    120     int audio_filepos; ///< file position of first audio packet in block
    121 
    122     /* stuff for quicktime */
    123     int fix_i_bps;
    124     float qt_last_a_pts;
    125 
    126     int subtitle_type;
    127 
    128     /* The timecodes of video frames might have to be reordered if they're
     81  int tnum;
     82  char *name;
     83 
     84  char *codec_id;
     85  int ms_compat;
     86  char *language;
     87
     88  int type;
     89 
     90  uint32_t v_width, v_height, v_dwidth, v_dheight;
     91  float v_frate;
     92
     93  uint32_t a_formattag;
     94  uint32_t a_channels, a_bps;
     95  float a_sfreq;
     96
     97  float default_duration;
     98
     99  int default_track;
     100
     101  void *private_data;
     102  unsigned int private_size;
     103
     104  /* stuff for realmedia */
     105  int realmedia;
     106  int rv_kf_base, rv_kf_pts;
     107  float rv_pts;  /* previous video timestamp */
     108  float ra_pts;  /* previous audio timestamp */
     109
     110  /** realaudio descrambling */
     111  int sub_packet_size; ///< sub packet size, per stream
     112  int sub_packet_h; ///< number of coded frames per block
     113  int coded_framesize; ///< coded frame size, per stream
     114  int audiopk_size; ///< audio packet size
     115  unsigned char *audio_buf; ///< place to store reordered audio data
     116  float *audio_timestamp; ///< timestamp for each audio packet
     117  int sub_packet_cnt; ///< number of subpacket already received
     118  int audio_filepos; ///< file position of first audio packet in block
     119
     120  /* stuff for quicktime */
     121  int fix_i_bps;
     122  float qt_last_a_pts;
     123
     124  int subtitle_type;
     125
     126  /* The timecodes of video frames might have to be reordered if they're
    129127     in display order (the timecodes, not the frames themselves!). In this
    130128     case demux packets have to be cached with the help of these variables. */
    131     int reorder_timecodes;
    132     demux_packet_t **cached_dps;
    133     int num_cached_dps, num_allocated_dps;
    134     float max_pts;
    135 
    136     /* generic content encoding support */
    137     mkv_content_encoding_t *encodings;
    138     int num_encodings;
    139 
    140     /* For VobSubs */
    141     mkv_sh_sub_t sh_sub;
     129  int reorder_timecodes;
     130  demux_packet_t **cached_dps;
     131  int num_cached_dps, num_allocated_dps;
     132  float max_pts;
     133
     134  /* generic content encoding support */
     135  mkv_content_encoding_t *encodings;
     136  int num_encodings;
     137
     138  /* For VobSubs and SSA/ASS */
     139  sh_sub_t sh_sub;
    142140} mkv_track_t;
    143141
    144142typedef struct mkv_index
    145143{
    146     int tnum;
    147     uint64_t timecode, filepos;
     144  int tnum;
     145  uint64_t timecode, filepos;
    148146} mkv_index_t;
    149147
     148typedef struct mkv_attachment
     149{
     150  char* name;
     151  char* mime;
     152  uint64_t uid;
     153  void* data;
     154  unsigned int data_size;
     155} mkv_attachment_t;
     156
    150157typedef struct mkv_demuxer
    151158{
    152     off_t segment_start;
    153 
    154     float duration, last_pts;
    155     uint64_t last_filepos;
    156 
    157     mkv_track_t **tracks;
    158     int num_tracks;
    159 
    160     uint64_t tc_scale, cluster_tc, first_tc;
    161     int has_first_tc;
    162 
    163     uint64_t clear_subs_at[SUB_MAX_TEXT];
    164     subtitle subs;
    165 
    166     uint64_t cluster_size;
    167     uint64_t blockgroup_size;
    168 
    169     mkv_index_t *indexes;
    170     int num_indexes;
    171 
    172     off_t *parsed_cues;
    173     int parsed_cues_num;
    174     off_t *parsed_seekhead;
    175     int parsed_seekhead_num;
    176 
    177     uint64_t *cluster_positions;
    178     int num_cluster_pos;
    179 
    180     int64_t skip_to_timecode;
    181     int v_skip_to_keyframe, a_skip_to_keyframe;
    182 
    183     int64_t stop_timecode;
    184 
    185     int last_aid;
    186     int audio_tracks[MAX_A_STREAMS];
     159  off_t segment_start;
     160
     161  float duration, last_pts;
     162  uint64_t last_filepos;
     163
     164  mkv_track_t **tracks;
     165  int num_tracks;
     166
     167  uint64_t tc_scale, cluster_tc, first_tc;
     168  int has_first_tc;
     169
     170  uint64_t clear_subs_at[SUB_MAX_TEXT];
     171  subtitle subs;
     172
     173  uint64_t cluster_size;
     174  uint64_t blockgroup_size;
     175
     176  mkv_index_t *indexes;
     177  int num_indexes;
     178
     179  off_t *parsed_cues;
     180  int parsed_cues_num;
     181  off_t *parsed_seekhead;
     182  int parsed_seekhead_num;
     183
     184  uint64_t *cluster_positions;
     185  int num_cluster_pos;
     186
     187  int64_t skip_to_timecode;
     188  int v_skip_to_keyframe, a_skip_to_keyframe;
     189
     190  int64_t stop_timecode;
     191 
     192  int last_aid;
     193  int audio_tracks[MAX_A_STREAMS];
     194 
     195  mkv_attachment_t *attachments;
     196  int num_attachments;
    187197} mkv_demuxer_t;
    188198
    … …  
    190200typedef struct
    191201{
    192     uint32_t chunks;              /* number of chunks */
    193     uint32_t timestamp;           /* timestamp from packet header */
    194     uint32_t len;                 /* length of actual data */
    195     uint32_t chunktab;            /* offset to chunk offset array */
     202  uint32_t chunks;              /* number of chunks */
     203  uint32_t timestamp;           /* timestamp from packet header */
     204  uint32_t len;                 /* length of actual data */
     205  uint32_t chunktab;            /* offset to chunk offset array */
    196206} dp_hdr_t;
    197207
    198208typedef struct __attribute__((__packed__))
    199209{
    200     uint32_t size;
    201     uint32_t fourcc1;
    202     uint32_t fourcc2;
    203     uint16_t width;
    204     uint16_t height;
    205     uint16_t bpp;
    206     uint32_t unknown1;
    207     uint32_t fps;
    208     uint32_t type1;
    209     uint32_t type2;
     210  uint32_t size;
     211  uint32_t fourcc1;
     212  uint32_t fourcc2;
     213  uint16_t width;
     214  uint16_t height;
     215  uint16_t bpp;
     216  uint32_t unknown1;
     217  uint32_t fps;
     218  uint32_t type1;
     219  uint32_t type2;
    210220} real_video_props_t;
    211221
    212222typedef struct __attribute__((__packed__))
    213223{
    214     uint32_t fourcc1;             /* '.', 'r', 'a', 0xfd */
    215     uint16_t version1;            /* 4 or 5 */
    216     uint16_t unknown1;            /* 00 000 */
    217     uint32_t fourcc2;             /* .ra4 or .ra5 */
    218     uint32_t unknown2;            /* ??? */
    219     uint16_t version2;            /* 4 or 5 */
    220     uint32_t header_size;         /* == 0x4e */
    221     uint16_t flavor;              /* codec flavor id */
    222     uint32_t coded_frame_size;    /* coded frame size */
    223     uint32_t unknown3;            /* big number */
    224     uint32_t unknown4;            /* bigger number */
    225     uint32_t unknown5;            /* yet another number */
    226     uint16_t sub_packet_h;
    227     uint16_t frame_size;
    228     uint16_t sub_packet_size;
    229     uint16_t unknown6;            /* 00 00 */
    230     uint16_t sample_rate;
    231     uint16_t unknown8;            /* 0 */
    232     uint16_t sample_size;
    233     uint16_t channels;
     224  uint32_t fourcc1;             /* '.', 'r', 'a', 0xfd */
     225  uint16_t version1;            /* 4 or 5 */
     226  uint16_t unknown1;            /* 00 000 */
     227  uint32_t fourcc2;             /* .ra4 or .ra5 */
     228  uint32_t unknown2;            /* ??? */
     229  uint16_t version2;            /* 4 or 5 */
     230  uint32_t header_size;         /* == 0x4e */
     231  uint16_t flavor;              /* codec flavor id */
     232  uint32_t coded_frame_size;    /* coded frame size */
     233  uint32_t unknown3;            /* big number */
     234  uint32_t unknown4;            /* bigger number */
     235  uint32_t unknown5;            /* yet another number */
     236  uint16_t sub_packet_h;
     237  uint16_t frame_size;
     238  uint16_t sub_packet_size;
     239  uint16_t unknown6;            /* 00 00 */
     240  uint16_t sample_rate;
     241  uint16_t unknown8;            /* 0 */
     242  uint16_t sample_size;
     243  uint16_t channels;
    234244} real_audio_v4_props_t;
    235245
    236246typedef struct __attribute__((__packed__))
    237247{
    238     uint32_t fourcc1;             /* '.', 'r', 'a', 0xfd */
    239     uint16_t version1;            /* 4 or 5 */
    240     uint16_t unknown1;            /* 00 000 */
    241     uint32_t fourcc2;             /* .ra4 or .ra5 */
    242     uint32_t unknown2;            /* ??? */
    243     uint16_t version2;            /* 4 or 5 */
    244     uint32_t header_size;         /* == 0x4e */
    245     uint16_t flavor;              /* codec flavor id */
    246     uint32_t coded_frame_size;    /* coded frame size */
    247     uint32_t unknown3;            /* big number */
    248     uint32_t unknown4;            /* bigger number */
    249     uint32_t unknown5;            /* yet another number */
    250     uint16_t sub_packet_h;
    251     uint16_t frame_size;
    252     uint16_t sub_packet_size;
    253     uint16_t unknown6;            /* 00 00 */
    254     uint8_t unknown7[6];          /* 0, srate, 0 */
    255     uint16_t sample_rate;
    256     uint16_t unknown8;            /* 0 */
    257     uint16_t sample_size;
    258     uint16_t channels;
    259     uint32_t genr;                /* "genr" */
    260     uint32_t fourcc3;             /* fourcc */
     248  uint32_t fourcc1;             /* '.', 'r', 'a', 0xfd */
     249  uint16_t version1;            /* 4 or 5 */
     250  uint16_t unknown1;            /* 00 000 */
     251  uint32_t fourcc2;             /* .ra4 or .ra5 */
     252  uint32_t unknown2;            /* ??? */
     253  uint16_t version2;            /* 4 or 5 */
     254  uint32_t header_size;         /* == 0x4e */
     255  uint16_t flavor;              /* codec flavor id */
     256  uint32_t coded_frame_size;    /* coded frame size */
     257  uint32_t unknown3;            /* big number */
     258  uint32_t unknown4;            /* bigger number */
     259  uint32_t unknown5;            /* yet another number */
     260  uint16_t sub_packet_h;
     261  uint16_t frame_size;
     262  uint16_t sub_packet_size;
     263  uint16_t unknown6;            /* 00 00 */
     264  uint8_t unknown7[6];          /* 0, srate, 0 */
     265  uint16_t sample_rate;
     266  uint16_t unknown8;            /* 0 */
     267  uint16_t sample_size;
     268  uint16_t channels;
     269  uint32_t genr;                /* "genr" */
     270  uint32_t fourcc3;             /* fourcc */
    261271} real_audio_v5_props_t;
    262272
    … …  
    265275extern char *dvdsub_lang;
    266276extern char *audio_lang;
    267 //extern int dvdsub_id;
    268 extern int demux_aid_vid_mismatch;
     277extern int dvdsub_id;
    269278
    270279/**
    … …  
    275284 */
    276285static void grow_array(void **array, int nelem, size_t elsize) {
    277     if (!(nelem & 31))
    278         *array = realloc(*array, (nelem + 32) * elsize);
     286  if (!(nelem & 31))
     287    *array = realloc(*array, (nelem + 32) * elsize);
    279288}
    280289
    281290static mkv_track_t *
    282     demux_mkv_find_track_by_num (mkv_demuxer_t *d, int n, int type)
    283 {
    284     int i, id;
    285 
    286     for (i=0, id=0; i < d->num_tracks; i++)
    287         if (d->tracks[i] != NULL && d->tracks[i]->type == type)
    288             if (id++ == n)
    289                 return d->tracks[i];
    290 
    291     return NULL;
     291demux_mkv_find_track_by_num (mkv_demuxer_t *d, int n, int type)
     292{
     293  int i, id;
     294
     295  for (i=0, id=0; i < d->num_tracks; i++)
     296    if (d->tracks[i] != NULL && d->tracks[i]->type == type)
     297      if (id++ == n)
     298        return d->tracks[i];
     299 
     300  return NULL;
    292301}
    293302
    … …  
    295304demux_mkv_find_track_by_language (mkv_demuxer_t *d, char *language, int type)
    296305{
    297     int i, len;
    298 
    299     language += strspn(language,",");
    300     while((len = strcspn(language,",")) > 0)
    301     {
    302         for (i=0; i < d->num_tracks; i++)
    303             if (d->tracks[i] != NULL && d->tracks[i]->language != NULL &&
    304                 d->tracks[i]->type == type &&
    305                 !strncmp(d->tracks[i]->language, language, len))
    306                 return d->tracks[i];
    307         language += len;
    308         language += strspn(language,",");
    309     }
    310 
    311     return NULL;
     306  int i, len;
     307 
     308  language += strspn(language,",");
     309  while((len = strcspn(language,",")) > 0)
     310    {
     311      for (i=0; i < d->num_tracks; i++)
     312        if (d->tracks[i] != NULL && d->tracks[i]->language != NULL &&
     313            d->tracks[i]->type == type &&
     314            !strncmp(d->tracks[i]->language, language, len))
     315          return d->tracks[i];
     316      language += len;
     317      language += strspn(language,",");
     318    }
     319 
     320  return NULL;
    312321}
    313322
    … …  
    315324add_cluster_position (mkv_demuxer_t *mkv_d, uint64_t position)
    316325{
    317     int i = mkv_d->num_cluster_pos;
    318 
    319     while (i--)
    320         if (mkv_d->cluster_positions[i] == position)
    321             return;
    322 
    323     grow_array(&mkv_d->cluster_positions, mkv_d->num_cluster_pos,
    324                sizeof(uint64_t));
    325     mkv_d->cluster_positions[mkv_d->num_cluster_pos++] = position;
     326  int i = mkv_d->num_cluster_pos;
     327
     328  while (i--)
     329    if (mkv_d->cluster_positions[i] == position)
     330      return;
     331
     332  grow_array(&mkv_d->cluster_positions, mkv_d->num_cluster_pos,
     333             sizeof(uint64_t));
     334  mkv_d->cluster_positions[mkv_d->num_cluster_pos++] = position;
    326335}
    327336
    … …  
    331340aac_get_sample_rate_index (uint32_t sample_rate)
    332341{
    333     if (92017 <= sample_rate)
    334         return 0;
    335     else if (75132 <= sample_rate)
    336         return 1;
    337     else if (55426 <= sample_rate)
    338         return 2;
    339     else if (46009 <= sample_rate)
    340         return 3;
    341     else if (37566 <= sample_rate)
    342         return 4;
    343     else if (27713 <= sample_rate)
    344         return 5;
    345     else if (23004 <= sample_rate)
    346         return 6;
    347     else if (18783 <= sample_rate)
    348         return 7;
    349     else if (13856 <= sample_rate)
    350         return 8;
    351     else if (11502 <= sample_rate)
    352         return 9;
    353     else if (9391 <= sample_rate)
    354         return 10;
    355     else
    356         return 11;
     342  if (92017 <= sample_rate)
     343    return 0;
     344  else if (75132 <= sample_rate)
     345    return 1;
     346  else if (55426 <= sample_rate)
     347    return 2;
     348  else if (46009 <= sample_rate)
     349    return 3;
     350  else if (37566 <= sample_rate)
     351    return 4;
     352  else if (27713 <= sample_rate)
     353    return 5;
     354  else if (23004 <= sample_rate)
     355    return 6;
     356  else if (18783 <= sample_rate)
     357    return 7;
     358  else if (13856 <= sample_rate)
     359    return 8;
     360  else if (11502 <= sample_rate)
     361    return 9;
     362  else if (9391 <= sample_rate)
     363    return 10;
     364  else
     365    return 11;
    357366}
    358367
    … …  
    361370vobsub_parse_size (mkv_track_t *t, const char *start)
    362371{
    363     if (sscanf(&start[6], "%dx%d", &t->sh_sub.width, &t->sh_sub.height) == 2)
    364     {
    365         dprintf("[mkv] VobSub size: %ux%u\n",
    366                 t->sh_sub.width, t->sh_sub.height);
    367         return 1;
    368     }
    369     return 0;
     372  if (sscanf(&start[6], "%dx%d", &t->sh_sub.width, &t->sh_sub.height) == 2)
     373    {
     374      dprintf("[mkv] VobSub size: %ux%u\n",
     375             t->sh_sub.width, t->sh_sub.height);
     376      return 1;
     377    }
     378  return 0;
    370379}
    371380
    … …  
    373382vobsub_parse_palette (mkv_track_t *t, const char *start)
    374383{
    375     int i, r, g, b, y, u, v, tmp;
    376 
    377     start += 8;
    378     while (isspace(*start))
     384  int i, r, g, b, y, u, v, tmp;
     385
     386  start += 8;
     387  while (isspace(*start))
     388    start++;
     389  for (i = 0; i < 16; i++)
     390    {
     391      if (sscanf(start, "%06x", &tmp) != 1)
     392        break;
     393      r = tmp >> 16 & 0xff;
     394      g = tmp >> 8 & 0xff;
     395      b = tmp & 0xff;
     396      y = MIN(MAX((int)(0.1494 * r + 0.6061 * g + 0.2445 * b), 0),
     397              0xff);
     398      u = MIN(MAX((int)(0.6066 * r - 0.4322 * g - 0.1744 * b) + 128,
     399                  0), 0xff);
     400      v = MIN(MAX((int)(-0.08435 * r - 0.3422 * g + 0.4266 * b) +
     401                  128, 0), 0xff);
     402      t->sh_sub.palette[i] = y << 16 | u << 8 | v;
     403      start += 6;
     404      while ((*start == ',') || isspace(*start))
    379405        start++;
    380     for (i = 0; i < 16; i++)
    381     {
    382         if (sscanf(start, "%06x", &tmp) != 1)
    383             break;
    384         r = tmp >> 16 & 0xff;
    385         g = tmp >> 8 & 0xff;
    386         b = tmp & 0xff;
    387         y = MIN(MAX((int)(0.1494 * r + 0.6061 * g + 0.2445 * b), 0),
    388                 0xff);
    389         u = MIN(MAX((int)(0.6066 * r - 0.4322 * g - 0.1744 * b) + 128,
    390                     0), 0xff);
    391         v = MIN(MAX((int)(-0.08435 * r - 0.3422 * g + 0.4266 * b) +
    392                     128, 0), 0xff);
    393         t->sh_sub.palette[i] = y << 16 | u << 8 | v;
    394         start += 6;
    395         while ((*start == ',') || isspace(*start))
    396             start++;
    397     }
    398     if (i == 16)
    399     {
    400         dprintf("[mkv] VobSub palette: %06x,%06x,"
    401                 "%06x,%06x,%06x,%06x,%06x,%06x,%06x,%06x,%06x,%06x,%06x,"
    402                 "%06x,%06x,%06x\n", t->sh_sub.palette[0],
    403                 t->sh_sub.palette[1], t->sh_sub.palette[2],
    404                 t->sh_sub.palette[3], t->sh_sub.palette[4],
    405                 t->sh_sub.palette[5], t->sh_sub.palette[6],
    406                 t->sh_sub.palette[7], t->sh_sub.palette[8],
    407                 t->sh_sub.palette[9], t->sh_sub.palette[10],
    408                 t->sh_sub.palette[11], t->sh_sub.palette[12],
    409                 t->sh_sub.palette[13], t->sh_sub.palette[14],
    410                 t->sh_sub.palette[15]);
    411         t->sh_sub.has_palette = 1;
    412         return 2;
    413     }
    414     return 0;
     406    }
     407  if (i == 16)
     408    {
     409      dprintf("[mkv] VobSub palette: %06x,%06x,"
     410             "%06x,%06x,%06x,%06x,%06x,%06x,%06x,%06x,%06x,%06x,%06x,"
     411             "%06x,%06x,%06x\n", t->sh_sub.palette[0],
     412             t->sh_sub.palette[1], t->sh_sub.palette[2],
     413             t->sh_sub.palette[3], t->sh_sub.palette[4],
     414             t->sh_sub.palette[5], t->sh_sub.palette[6],
     415             t->sh_sub.palette[7], t->sh_sub.palette[8],
     416             t->sh_sub.palette[9], t->sh_sub.palette[10],
     417             t->sh_sub.palette[11], t->sh_sub.palette[12],
     418             t->sh_sub.palette[13], t->sh_sub.palette[14],
     419             t->sh_sub.palette[15]);
     420      t->sh_sub.has_palette = 1;
     421      return 2;
     422    }
     423  return 0;
    415424}
    416425
    … …  
    418427vobsub_parse_custom_colors (mkv_track_t *t, const char *start)
    419428{
    420     int use_custom_colors, i;
    421 
    422     use_custom_colors = 0;
    423     start += 14;
    424     while (isspace(*start))
    425         start++;
    426     if (!strncasecmp(start, "ON", 2) || (*start == '1'))
    427         use_custom_colors = 1;
    428     else if (!strncasecmp(start, "OFF", 3) || (*start == '0'))
    429         use_custom_colors = 0;
    430     dprintf("[mkv] VobSub custom colors: %s\n",
    431             use_custom_colors ? "ON" : "OFF");
    432     if ((start = strstr(start, "colors:")) != NULL)
    433     {
    434         start += 7;
    435         while (isspace(*start))
    436             start++;
    437         for (i = 0; i < 4; i++)
    438         {
    439             if (sscanf(start, "%06x", &t->sh_sub.colors[i]) != 1)
    440                 break;
    441             start += 6;
    442             while ((*start == ',') || isspace(*start))
    443                 start++;
    444         }
    445         if (i == 4)
    446         {
    447             t->sh_sub.custom_colors = 4;
    448             dprintf("[mkv] VobSub colors: %06x,"
    449                     "%06x,%06x,%06x\n", t->sh_sub.colors[0],
    450                     t->sh_sub.colors[1], t->sh_sub.colors[2],
    451                     t->sh_sub.colors[3]);
    452         }
    453     }
    454     if (!use_custom_colors)
    455         t->sh_sub.custom_colors = 0;
    456     return 4;
     429  int use_custom_colors, i;
     430
     431  use_custom_colors = 0;
     432  start += 14;
     433  while (isspace(*start))
     434    start++;
     435   if (!strncasecmp(start, "ON", 2) || (*start == '1'))
     436     use_custom_colors = 1;
     437   else if (!strncasecmp(start, "OFF", 3) || (*start == '0'))
     438     use_custom_colors = 0;
     439   dprintf("[mkv] VobSub custom colors: %s\n",
     440          use_custom_colors ? "ON" : "OFF");
     441   if ((start = strstr(start, "colors:")) != NULL)
     442     {
     443       start += 7;
     444       while (isspace(*start))
     445         start++;
     446       for (i = 0; i < 4; i++)
     447         {
     448           if (sscanf(start, "%06x", &t->sh_sub.colors[i]) != 1)
     449             break;
     450           start += 6;
     451           while ((*start == ',') || isspace(*start))
     452             start++;
     453         }
     454       if (i == 4)
     455         {
     456           t->sh_sub.custom_colors = 4;
     457           dprintf("[mkv] VobSub colors: %06x,"
     458                  "%06x,%06x,%06x\n", t->sh_sub.colors[0],
     459                  t->sh_sub.colors[1], t->sh_sub.colors[2],
     460                  t->sh_sub.colors[3]);
     461         }
     462     }
     463   if (!use_custom_colors)
     464     t->sh_sub.custom_colors = 0;
     465   return 4;
    457466}
    458467
    … …  
    460469vobsub_parse_forced_subs (mkv_track_t *t, const char *start)
    461470{
    462     start += 12;
    463     while (isspace(*start))
    464         start++;
    465     if (!strncasecmp(start, "on", 2) || (*start == '1'))
    466         t->sh_sub.forced_subs_only = 1;
    467     else if (!strncasecmp(start, "off", 3) || (*start == '0'))
    468         t->sh_sub.forced_subs_only = 0;
    469     else
    470         return 0;
    471     dprintf("[mkv] VobSub forced subs: %d\n",
    472             t->sh_sub.forced_subs_only);
    473     return 8;
     471  start += 12;
     472  while (isspace(*start))
     473    start++;
     474  if (!strncasecmp(start, "on", 2) || (*start == '1'))
     475    t->sh_sub.forced_subs_only = 1;
     476  else if (!strncasecmp(start, "off", 3) || (*start == '0'))
     477    t->sh_sub.forced_subs_only = 0;
     478  else
     479    return 0;
     480  dprintf("[mkv] VobSub forced subs: %d\n",
     481         t->sh_sub.forced_subs_only);
     482  return 8;
    474483}
    475484
    … …  
    485494free_cached_dps (demuxer_t *demuxer)
    486495{
    487     mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
    488     mkv_track_t *track;
    489     int i, k;
    490 
    491     for (k = 0; k < mkv_d->num_tracks; k++)
    492     {
    493         track = mkv_d->tracks[k];
    494         for (i = 0; i < track->num_cached_dps; i++)
    495             free_demux_packet (track->cached_dps[i]);
    496         free(track->cached_dps);
    497         track->cached_dps = NULL;
    498         track->num_cached_dps = 0;
    499         track->num_allocated_dps = 0;
    500         track->max_pts = 0;
     496  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
     497  mkv_track_t *track;
     498  int i, k;
     499
     500  for (k = 0; k < mkv_d->num_tracks; k++)
     501    {
     502      track = mkv_d->tracks[k];
     503      for (i = 0; i < track->num_cached_dps; i++)
     504        free_demux_packet (track->cached_dps[i]);
     505      free(track->cached_dps);
     506      track->cached_dps = NULL;
     507      track->num_cached_dps = 0;
     508      track->num_allocated_dps = 0;
     509      track->max_pts = 0;
    501510    }
    502511}
    … …  
    505514demux_mkv_parse_idx (mkv_track_t *t)
    506515{
    507     int things_found, last;
    508     char *buf, *pos, *start;
    509 
    510     if ((t->private_data == NULL) || (t->private_size == 0))
    511         return 0;
    512 
    513     things_found = 0;
    514     buf = (char *)malloc(t->private_size + 1);
    515     if (buf == NULL)
    516         return 0;
    517     memcpy(buf, t->private_data, t->private_size);
    518     buf[t->private_size] = 0;
    519     t->sh_sub.type = 'v';
    520     t->sh_sub.has_palette = 0;
    521 
    522     pos = buf;
    523     start = buf;
    524     last = 0;
    525     do
    526     {
    527         if ((*pos == 0) || (*pos == '\r') || (*pos == '\n'))
    528         {
    529             if (*pos == 0)
    530                 last = 1;
    531             *pos = 0;
    532 
    533             if (!strncasecmp(start, "size: ", 6))
    534                 things_found |= vobsub_parse_size(t, start);
    535             else if (!strncasecmp(start, "palette:", 8))
    536                 things_found |= vobsub_parse_palette(t, start);
    537             else if (!strncasecmp(start, "custom colors:", 14))
    538                 things_found |= vobsub_parse_custom_colors(t, start);
    539             else if (!strncasecmp(start, "forced subs:", 12))
    540                 things_found |= vobsub_parse_forced_subs(t, start);
    541 
    542             if (last)
    543                 break;
    544             do
     516  int things_found, last;
     517  char *buf, *pos, *start;
     518
     519  if ((t->private_data == NULL) || (t->private_size == 0))
     520    return 0;
     521
     522  things_found = 0;
     523  buf = malloc(t->private_size + 1);
     524  if (buf == NULL)
     525    return 0;
     526  memcpy(buf, t->private_data, t->private_size);
     527  buf[t->private_size] = 0;
     528  t->sh_sub.type = 'v';
     529  t->sh_sub.has_palette = 0;
     530
     531  pos = buf;
     532  start = buf;
     533  last = 0;
     534  do
     535    {
     536      if ((*pos == 0) || (*pos == '\r') || (*pos == '\n'))
     537        {
     538          if (*pos == 0)
     539            last = 1;
     540          *pos = 0;
     541
     542          if (!strncasecmp(start, "size: ", 6))
     543            things_found |= vobsub_parse_size(t, start);
     544          else if (!strncasecmp(start, "palette:", 8))
     545            things_found |= vobsub_parse_palette(t, start);
     546          else if (!strncasecmp(start, "custom colors:", 14))
     547            things_found |= vobsub_parse_custom_colors(t, start);
     548          else if (!strncasecmp(start, "forced subs:", 12))
     549            things_found |= vobsub_parse_forced_subs(t, start);
     550
     551          if (last)
     552            break;
     553          do
    545554            {
    546                 pos++;
     555              pos++;
    547556            }
    548             while ((*pos == '\r') || (*pos == '\n'));
    549             start = pos;
    550         }
    551         else
    552             pos++;
    553     }
    554     while (!last && (*start != 0));
    555 
    556     free(buf);
    557 
    558     return (things_found & 3) == 3;
     557          while ((*pos == '\r') || (*pos == '\n'));
     558          start = pos;
     559        }
     560      else
     561        pos++;
     562    }
     563  while (!last && (*start != 0));
     564
     565  free(buf);
     566
     567  return (things_found & 3) == 3;
    559568}
    560569
    … …  
    564573                  uint32_t *size, uint32_t type)
    565574{
    566     int i, result;
    567     int modified = 0;
    568 
    569     *dest = src;
    570     if (track->num_encodings <= 0)
    571         return 0;
    572 
    573     for (i=0; i<track->num_encodings; i++)
    574     {
    575         if (!(track->encodings[i].scope & type))
    576             continue;
     575  int i, result;
     576  int modified = 0;
     577
     578  *dest = src;
     579  if (track->num_encodings <= 0)
     580    return 0;
     581
     582  for (i=0; i<track->num_encodings; i++)
     583    {
     584      if (!(track->encodings[i].scope & type))
     585        continue;
    577586
    578587#ifdef HAVE_ZLIB
    579         if (track->encodings[i].comp_algo == 0)
    580         {
    581             /* zlib encoded track */
    582             z_stream zstream;
    583 
    584             zstream.zalloc = (alloc_func) 0;
    585             zstream.zfree = (free_func) 0;
    586             zstream.opaque = (voidpf) 0;
    587             if (inflateInit (&zstream) != Z_OK)
     588      if (track->encodings[i].comp_algo == 0)
     589        {
     590          /* zlib encoded track */
     591          z_stream zstream;
     592
     593          zstream.zalloc = (alloc_func) 0;
     594          zstream.zfree = (free_func) 0;
     595          zstream.opaque = (voidpf) 0;
     596          if (inflateInit (&zstream) != Z_OK)
    588597            {
    589                 dprintf (
    590                          "[mkv] zlib initialization failed.\n");
     598              dprintf(
     599                      MSGTR_MPDEMUX_MKV_ZlibInitializationFailed);
     600              return modified;
     601            }
     602          zstream.next_in = (Bytef *) src;
     603          zstream.avail_in = *size;
     604
     605          modified = 1;
     606          *dest = malloc (*size);
     607          zstream.avail_out = *size;
     608          do {
     609            *size += 4000;
     610            *dest = realloc (*dest, *size);
     611            zstream.next_out = (Bytef *) (*dest + zstream.total_out);
     612            result = inflate (&zstream, Z_NO_FLUSH);
     613            if (result != Z_OK && result != Z_STREAM_END)
     614              {
     615                dprintf(
     616                        MSGTR_MPDEMUX_MKV_ZlibDecompressionFailed);
     617                free(*dest);
     618                *dest = NULL;
     619                inflateEnd (&zstream);
    591620                return modified;
     621              }
     622            zstream.avail_out += 4000;
     623          } while (zstream.avail_out == 4000 &&
     624                   zstream.avail_in != 0 && result != Z_STREAM_END);
     625
     626          *size = zstream.total_out;
     627          inflateEnd (&zstream);
     628        }
     629#endif
     630      if (track->encodings[i].comp_algo == 2)
     631        {
     632          /* lzo encoded track */
     633          int dstlen = *size * 3;
     634
     635          if (lzo_init () != LZO_E_OK)
     636            {
     637              dprintf(
     638                      MSGTR_MPDEMUX_MKV_LzoInitializationFailed);
     639              return modified;
    592640            }
    593             zstream.next_in = (Bytef *) src;
    594             zstream.avail_in = *size;
    595 
    596             modified = 1;
    597             *dest = (uint8_t *) malloc (*size);
    598             zstream.avail_out = *size;
    599             do {
    600                 *size += 4000;
    601                 *dest = (uint8_t *) realloc (*dest, *size);
    602                 zstream.next_out = (Bytef *) (*dest + zstream.total_out);
    603                 result = inflate (&zstream, Z_NO_FLUSH);
    604                 if (result != Z_OK && result != Z_STREAM_END)
     641
     642          *dest = malloc (dstlen);
     643          while (1)
     644            {
     645              result = lzo1x_decompress_safe (src, *size, *dest, &dstlen,
     646                                              NULL);
     647              if (result == LZO_E_OK)
     648                break;
     649              if (result != LZO_E_OUTPUT_OVERRUN)
    605650                {
    606                     dprintf (
    607                              "[mkv] zlib decompression failed.\n");
    608                     free(*dest);
    609                     *dest = NULL;
    610                     inflateEnd (&zstream);
    611                     return modified;
     651                  dprintf(
     652                          MSGTR_MPDEMUX_MKV_LzoDecompressionFailed);
     653                  return modified;
    612654                }
    613                 zstream.avail_out += 4000;
    614             } while (zstream.avail_out == 4000 &&
    615                      zstream.avail_in != 0 && result != Z_STREAM_END);
    616 
    617             *size = zstream.total_out;
    618             inflateEnd (&zstream);
    619         }
    620 #endif
    621         if (track->encodings[i].comp_algo == 2)
    622         {
    623             /* lzo encoded track */
    624             int dstlen = *size * 3;
    625 
    626             if (lzo_init () != LZO_E_OK)
    627             {
    628                 dprintf (
    629                          "[mkv] lzo initialization failed.\n");
    630                 return modified;
     655              dprintf("[mkv] lzo decompression buffer too small.\n");
     656              dstlen *= 2;
     657              *dest = realloc (*dest, dstlen);
    631658            }
    632 
    633             *dest = (uint8_t *) malloc (dstlen);
    634             while (1)
    635             {
    636                 result = lzo1x_decompress_safe (src, *size, *dest, &dstlen,
    637                                                 NULL);
    638                 if (result == LZO_E_OK)
    639                     break;
    640                 if (result != LZO_E_OUTPUT_OVERRUN)
    641                 {
    642                     dprintf (
    643                              "[mkv] lzo decompression failed.\n");
    644                     return modified;
    645                 }
    646                 dprintf (
    647                          "[mkv] lzo decompression buffer too small.\n");
    648                 dstlen *= 2;
    649                 *dest = (uint8_t *) realloc (*dest, dstlen);
    650             }
    651             *size = dstlen;
    652         }
    653     }
    654 
    655     return modified;
     659          *size = dstlen;
     660        }
     661    }
     662
     663  return modified;
    656664}
    657665
    … …  
    660668demux_mkv_read_info (demuxer_t *demuxer)
    661669{
    662     mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
    663     stream_t *s = demuxer->stream;
    664     uint64_t length, l;
    665     int il;
    666     uint64_t tc_scale = 1000000;
    667     long double duration = 0.;
    668 
    669     length = ebml_read_length (s, NULL);
    670     while (length > 0)
    671     {
    672         switch (ebml_read_id (s, &il))
     670  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
     671  stream_t *s = demuxer->stream;
     672  uint64_t length, l;
     673  int il;
     674  uint64_t tc_scale = 1000000;
     675  long double duration = 0.;
     676
     677  length = ebml_read_length (s, NULL);
     678  while (length > 0)
     679    {
     680      switch (ebml_read_id (s, &il))
    673681        {
    674682        case MATROSKA_ID_TIMECODESCALE:
    675             {
    676                 uint64_t num = ebml_read_uint (s, &l);
    677                 if (num == EBML_UINT_INVALID)
    678                     return 1;
    679                 tc_scale = num;
    680                 dprintf ("[mkv] | + timecode scale: %"PRIu64"\n",
    681                          tc_scale);
    682                 break;
    683             }
     683          {
     684            uint64_t num = ebml_read_uint (s, &l);
     685            if (num == EBML_UINT_INVALID)
     686              return 1;
     687            tc_scale = num;
     688            dprintf("[mkv] | + timecode scale: %"PRIu64"\n",
     689                    tc_scale);
     690            break;
     691          }
    684692
    685693        case MATROSKA_ID_DURATION:
    686             {
    687                 long double num = ebml_read_float (s, &l);
    688                 if (num == EBML_FLOAT_INVALID)
    689                     return 1;
    690                 duration = num;
    691                 dprintf("[mkv] | + duration: %.3Lfs\n",
    692                         duration * tc_scale / 1000000000.0);
    693                 break;
    694             }
     694          {
     695            long double num = ebml_read_float (s, &l);
     696            if (num == EBML_FLOAT_INVALID)
     697              return 1;
     698            duration = num;
     699            dprintf("[mkv] | + duration: %.3Lfs\n",
     700                    duration * tc_scale / 1000000000.0);
     701            break;
     702          }
    695703
    696704        default:
    697             ebml_read_skip (s, &l);
    698             break;
    699         }
    700         length -= l + il;
    701     }
    702     mkv_d->tc_scale = tc_scale;
    703     mkv_d->duration = duration * tc_scale / 1000000000.0;
    704     return 0;
     705          ebml_read_skip (s, &l);
     706          break;
     707        }
     708      length -= l + il;
     709    }
     710  mkv_d->tc_scale = tc_scale;
     711  mkv_d->duration = duration * tc_scale / 1000000000.0;
     712  return 0;
    705713}
    706714
    … …  
    713721demux_mkv_free_encodings(mkv_content_encoding_t *encodings, int numencodings)
    714722{
    715     while (numencodings-- > 0)
    716         free(encodings[numencodings].comp_settings);
    717     free(encodings);
     723  while (numencodings-- > 0)
     724    free(encodings[numencodings].comp_settings);
     725  free(encodings);
    718726}
    719727
    … …  
    721729demux_mkv_read_trackencodings (demuxer_t *demuxer, mkv_track_t *track)
    722730{
    723     stream_t *s = demuxer->stream;
    724     mkv_content_encoding_t *ce, e;
    725     uint64_t len, length, l;
    726     int il, n;
    727 
    728     ce = (mkv_content_encoding_t *) malloc (sizeof (*ce));
    729     n = 0;
    730 
    731     len = length = ebml_read_length (s, &il);
    732     len += il;
    733     while (length > 0)
    734     {
    735         switch (ebml_read_id (s, &il))
     731  stream_t *s = demuxer->stream;
     732  mkv_content_encoding_t *ce, e;
     733  uint64_t len, length, l;
     734  int il, n;
     735
     736  ce = malloc (sizeof (*ce));
     737  n = 0;
     738
     739  len = length = ebml_read_length (s, &il);
     740  len += il;
     741  while (length > 0)
     742    {
     743      switch (ebml_read_id (s, &il))
    736744        {
    737745        case MATROSKA_ID_CONTENTENCODING:
    738             {
    739                 uint64_t len;
    740                 int i;
    741 
    742                 memset (&e, 0, sizeof (e));
    743                 e.scope = 1;
    744 
    745                 len = ebml_read_length (s, &i);
    746                 l = len + i;
    747 
    748                 while (len > 0)
    749                 {
    750                     uint64_t num, l;
    751                     int il;
    752 
    753                     switch (ebml_read_id (s, &il))
     746          {
     747            uint64_t len;
     748            int i;
     749
     750            memset (&e, 0, sizeof (e));
     751            e.scope = 1;
     752
     753            len = ebml_read_length (s, &i);
     754            l = len + i;
     755
     756            while (len > 0)
     757              {
     758                uint64_t num, l;
     759                int il;
     760
     761                switch (ebml_read_id (s, &il))
     762                  {
     763                  case MATROSKA_ID_CONTENTENCODINGORDER:
     764                    num = ebml_read_uint (s, &l);
     765                    if (num == EBML_UINT_INVALID)
     766                      goto err_out;
     767                    e.order = num;
     768                    break;
     769
     770                  case MATROSKA_ID_CONTENTENCODINGSCOPE:
     771                    num = ebml_read_uint (s, &l);
     772                    if (num == EBML_UINT_INVALID)
     773                      goto err_out;
     774                    e.scope = num;
     775                    break;
     776
     777                  case MATROSKA_ID_CONTENTENCODINGTYPE:
     778                    num = ebml_read_uint (s, &l);
     779                    if (num == EBML_UINT_INVALID)
     780                      goto err_out;
     781                    e.type = num;
     782                    break;
     783
     784                  case MATROSKA_ID_CONTENTCOMPRESSION:
    754785                    {
    755                     case MATROSKA_ID_CONTENTENCODINGORDER:
    756                         num = ebml_read_uint (s, &l);
    757                         if (num == EBML_UINT_INVALID)
    758                             goto err_out;
    759                         e.order = num;
    760                         break;
    761 
    762                     case MATROSKA_ID_CONTENTENCODINGSCOPE:
    763                         num = ebml_read_uint (s, &l);
    764                         if (num == EBML_UINT_INVALID)
    765                             goto err_out;
    766                         e.scope = num;
    767                         break;
    768 
    769                     case MATROSKA_ID_CONTENTENCODINGTYPE:
    770                         num = ebml_read_uint (s, &l);
    771                         if (num == EBML_UINT_INVALID)
    772                             goto err_out;
    773                         e.type = num;
    774                         break;
    775 
    776                     case MATROSKA_ID_CONTENTCOMPRESSION:
     786                      uint64_t le;
     787
     788                      le = ebml_read_length (s, &i);
     789                      l = le + i;
     790
     791                      while (le > 0)
    777792                        {
    778                             uint64_t le;
    779 
    780                             le = ebml_read_length (s, &i);
    781                             l = le + i;
    782 
    783                             while (le > 0)
     793                          uint64_t l;
     794                          int il;
     795
     796                          switch (ebml_read_id (s, &il))
    784797                            {
    785                                 uint64_t l;
    786                                 int il;
    787 
    788                                 switch (ebml_read_id (s, &il))
    789                                 {
    790                                 case MATROSKA_ID_CONTENTCOMPALGO:
    791                                     num = ebml_read_uint (s, &l);
    792                                     if (num == EBML_UINT_INVALID)
    793                                         goto err_out;
    794                                     e.comp_algo = num;
    795                                     break;
    796 
    797                                 case MATROSKA_ID_CONTENTCOMPSETTINGS:
    798                                     l = ebml_read_length (s, &i);
    799                                     e.comp_settings = (uint8_t *) malloc (l);
    800                                     stream_read (s, e.comp_settings, l);
    801                                     e.comp_settings_len = l;
    802                                     l += i;
    803                                     break;
    804 
    805                                 default:
    806                                     ebml_read_skip (s, &l);
    807                                     break;
    808                                 }
    809                                 le -= l + il;
     798                            case MATROSKA_ID_CONTENTCOMPALGO:
     799                              num = ebml_read_uint (s, &l);
     800                              if (num == EBML_UINT_INVALID)
     801                                goto err_out;
     802                              e.comp_algo = num;
     803                              break;
     804
     805                            case MATROSKA_ID_CONTENTCOMPSETTINGS:
     806                              l = ebml_read_length (s, &i);
     807                              e.comp_settings = malloc (l);
     808                              stream_read (s, e.comp_settings, l);
     809                              e.comp_settings_len = l;
     810                              l += i;
     811                              break;
     812
     813                            default:
     814                              ebml_read_skip (s, &l);
     815                              break;
    810816                            }
    811 
    812                             if (e.type == 1)
    813                             {
    814                                 dprintf(
    815                                         "[mkv] Track number %u has been encrypted "
    816                                         "and decryption has not yet been implemented."
    817                                         " Skipping track.\n", track->tnum);
    818                             }
    819                             else if (e.type != 0)
    820                             {
    821                                 dprintf(
    822                                         "[mkv] Unknown content encoding type for "
    823                                         "track %u. Skipping track.\n", track->tnum);
    824                             }
    825 
    826                             if (e.comp_algo != 0 && e.comp_algo != 2)
    827                             {
    828                                 dprintf (
    829                                          "[mkv] Track %u has been compressed with an "
    830                                          "unknown/unsupported compression algorithm "
    831                                          "(%u). Skipping track.\n",
    832                                          track->tnum, e.comp_algo);
    833                             }
     817                          le -= l + il;
     818                        }
     819
     820                      if (e.type == 1)
     821                        {
     822                          dprintf(
     823                                 MSGTR_MPDEMUX_MKV_TrackEncrypted, track->tnum);
     824                        }
     825                      else if (e.type != 0)
     826                        {
     827                          dprintf(
     828                                 MSGTR_MPDEMUX_MKV_UnknownContentEncoding, track->tnum);
     829                        }
     830
     831                      if (e.comp_algo != 0 && e.comp_algo != 2)
     832                        {
     833                          dprintf(
     834                                  MSGTR_MPDEMUX_MKV_UnknownCompression,
     835                                  track->tnum, e.comp_algo);
     836                        }
    834837#ifndef HAVE_ZLIB
    835                             else if (e.comp_algo == 0)
    836                             {
    837                                 dprintf (
    838                                          "Track %u was compressed with zlib but "
    839                                          "mplayer has not been compiled with support "
    840                                          "for zlib compression. Skipping track.\n",
    841                                          track->tnum);
    842                             }
     838                      else if (e.comp_algo == 0)
     839                        {
     840                          dprintf(
     841                                  MSGTR_MPDEMUX_MKV_ZlibCompressionUnsupported,
     842                                  track->tnum);
     843                        }
    843844#endif
    844845
    845                             break;
    846                         }
    847 
    848                     default:
    849                         ebml_read_skip (s, &l);
    850                         break;
     846                      break;
    851847                    }
    852                     len -= l + il;
    853                 }
    854                 for (i=0; i<n; i++)
    855                     if (e.order <= ce[i].order)
    856                         break;
    857                 ce = (mkv_content_encoding_t *) realloc (ce, (n+1) *sizeof (*ce));
    858                 memmove (ce+i+1, ce+i, (n-i) * sizeof (*ce));
    859                 memcpy (ce+i, &e, sizeof (e));
    860                 n++;
     848
     849                  default:
     850                    ebml_read_skip (s, &l);
     851                    break;
     852                  }
     853                len -= l + il;
     854              }
     855            for (i=0; i<n; i++)
     856              if (e.order <= ce[i].order)
    861857                break;
    862             }
     858            ce = realloc (ce, (n+1) *sizeof (*ce));
     859            memmove (ce+i+1, ce+i, (n-i) * sizeof (*ce));
     860            memcpy (ce+i, &e, sizeof (e));
     861            n++;
     862            break;
     863          }
     864
     865        default:
     866          ebml_read_skip (s, &l);
     867          break;
     868        }
     869
     870      length -= l + il;
     871    }
     872
     873  track->encodings = ce;
     874  track->num_encodings = n;
     875  return len;
     876
     877err_out:
     878  demux_mkv_free_encodings(ce, n);
     879  return 0;
     880}
     881
     882static int
     883demux_mkv_read_trackaudio (demuxer_t *demuxer, mkv_track_t *track)
     884{
     885  stream_t *s = demuxer->stream;
     886  uint64_t len, length, l;
     887  int il;
     888
     889  track->a_sfreq = 8000.0;
     890  track->a_channels = 1;
     891
     892  len = length = ebml_read_length (s, &il);
     893  len += il;
     894  while (length > 0)
     895    {
     896      switch (ebml_read_id (s, &il))
     897        {
     898        case MATROSKA_ID_AUDIOSAMPLINGFREQ:
     899          {
     900            long double num = ebml_read_float (s, &l);
     901            if (num == EBML_FLOAT_INVALID)
     902              return 0;
     903            track->a_sfreq = num;
     904            dprintf("[mkv] |   + Sampling frequency: %f\n",
     905                    track->a_sfreq);
     906            break;
     907          }
     908
     909        case MATROSKA_ID_AUDIOBITDEPTH:
     910          {
     911            uint64_t num = ebml_read_uint (s, &l);
     912            if (num == EBML_UINT_INVALID)
     913              return 0;
     914            track->a_bps = num;
     915            dprintf("[mkv] |   + Bit depth: %u\n",
     916                    track->a_bps);
     917            break;
     918          }
     919
     920        case MATROSKA_ID_AUDIOCHANNELS:
     921          {
     922            uint64_t num = ebml_read_uint (s, &l);
     923            if (num == EBML_UINT_INVALID)
     924              return 0;
     925            track->a_channels = num;
     926            dprintf("[mkv] |   + Channels: %u\n",
     927                    track->a_channels);
     928            break;
     929          }
    863930
    864931        default:
    … …  
    866933            break;
    867934        }
    868 
    869         length -= l + il;
    870     }
    871 
    872     track->encodings = ce;
    873     track->num_encodings = n;
    874     return len;
    875 
    876 err_out:
    877     demux_mkv_free_encodings(ce, n);
    878     return 0;
     935      length -= l + il;
     936    }
     937  return len;
    879938}
    880939
    881940static int
    882 demux_mkv_read_trackaudio (demuxer_t *demuxer, mkv_track_t *track)
    883 {
    884     stream_t *s = demuxer->stream;
    885     uint64_t len, length, l;
    886     int il;
    887 
    888     track->a_sfreq = 8000.0;
    889     track->a_channels = 1;
    890 
    891     len = length = ebml_read_length (s, &il);
    892     len += il;
    893     while (length > 0)
    894     {
    895         switch (ebml_read_id (s, &il))
    896         {
    897         case MATROSKA_ID_AUDIOSAMPLINGFREQ:
    898             {
    899                 long double num = ebml_read_float (s, &l);
    900                 if (num == EBML_FLOAT_INVALID)
    901                     return 0;
    902                 track->a_sfreq = num;
    903                 dprintf ("[mkv] |   + Sampling frequency: %f\n",
    904                          track->a_sfreq);
    905                 break;
    906             }
    907 
    908         case MATROSKA_ID_AUDIOBITDEPTH:
    909             {
    910                 uint64_t num = ebml_read_uint (s, &l);
    911                 if (num == EBML_UINT_INVALID)
    912                     return 0;
    913                 track->a_bps = num;
    914                 dprintf ("[mkv] |   + Bit depth: %u\n",
    915                          track->a_bps);
    916                 break;
    917             }
    918 
    919         case MATROSKA_ID_AUDIOCHANNELS:
    920             {
    921                 uint64_t num = ebml_read_uint (s, &l);
    922                 if (num == EBML_UINT_INVALID)
    923                     return 0;
    924                 track->a_channels = num;
    925                 dprintf ("[mkv] |   + Channels: %u\n",
    926                          track->a_channels);
    927                 break;
    928             }
     941demux_mkv_read_trackvideo (demuxer_t *demuxer, mkv_track_t *track)
     942{
     943  stream_t *s = demuxer->stream;
     944  uint64_t len, length, l;
     945  int il;
     946
     947  len = length = ebml_read_length (s, &il);
     948  len += il;
     949  while (length > 0)
     950    {
     951      switch (ebml_read_id (s, &il))
     952        {
     953        case MATROSKA_ID_VIDEOFRAMERATE:
     954          {
     955            long double num = ebml_read_float (s, &l);
     956            if (num == EBML_FLOAT_INVALID)
     957              return 0;
     958            track->v_frate = num;
     959            dprintf("[mkv] |   + Frame rate: %f\n",
     960                    track->v_frate);
     961            if (track->v_frate > 0)
     962              track->default_duration = 1 / track->v_frate;
     963            break;
     964          }
     965
     966        case MATROSKA_ID_VIDEODISPLAYWIDTH:
     967          {
     968            uint64_t num = ebml_read_uint (s, &l);
     969            if (num == EBML_UINT_INVALID)
     970              return 0;
     971            track->v_dwidth = num;
     972            dprintf("[mkv] |   + Display width: %u\n",
     973                    track->v_dwidth);
     974            break;
     975          }
     976
     977        case MATROSKA_ID_VIDEODISPLAYHEIGHT:
     978          {
     979            uint64_t num = ebml_read_uint (s, &l);
     980            if (num == EBML_UINT_INVALID)
     981              return 0;
     982            track->v_dheight = num;
     983            dprintf("[mkv] |   + Display height: %u\n",
     984                    track->v_dheight);
     985            break;
     986          }
     987
     988        case MATROSKA_ID_VIDEOPIXELWIDTH:
     989          {
     990            uint64_t num = ebml_read_uint (s, &l);
     991            if (num == EBML_UINT_INVALID)
     992              return 0;
     993            track->v_width = num;
     994            dprintf("[mkv] |   + Pixel width: %u\n",
     995                    track->v_width);
     996            break;
     997          }
     998
     999        case MATROSKA_ID_VIDEOPIXELHEIGHT:
     1000          {
     1001            uint64_t num = ebml_read_uint (s, &l);
     1002            if (num == EBML_UINT_INVALID)
     1003              return 0;
     1004            track->v_height = num;
     1005            dprintf("[mkv] |   + Pixel height: %u\n",
     1006                    track->v_height);
     1007            break;
     1008          }
    9291009
    9301010        default:
    … …  
    9321012            break;
    9331013        }
    934         length -= l + il;
    935     }
    936     return len;
    937 }
    938 
    939 static int
    940 demux_mkv_read_trackvideo (demuxer_t *demuxer, mkv_track_t *track)
    941 {
    942     stream_t *s = demuxer->stream;
    943     uint64_t len, length, l;
    944     int il;
    945 
    946     len = length = ebml_read_length (s, &il);
    947     len += il;
    948     while (length > 0)
    949     {
    950         switch (ebml_read_id (s, &il))
    951         {
    952         case MATROSKA_ID_VIDEOFRAMERATE:
    953             {
    954                 long double num = ebml_read_float (s, &l);
    955                 if (num == EBML_FLOAT_INVALID)
    956                     return 0;
    957                 track->v_frate = num;
    958                 dprintf ("[mkv] |   + Frame rate: %f\n",
    959                          track->v_frate);
    960                 if (track->v_frate > 0)
    961                     track->default_duration = 1 / track->v_frate;
    962                 break;
    963             }
    964 
    965         case MATROSKA_ID_VIDEODISPLAYWIDTH:
    966             {
    967                 uint64_t num = ebml_read_uint (s, &l);
    968                 if (num == EBML_UINT_INVALID)
    969                     return 0;
    970                 track->v_dwidth = num;
    971                 dprintf ("[mkv] |   + Display width: %u\n",
    972                          track->v_dwidth);
    973                 break;
    974             }
    975 
    976         case MATROSKA_ID_VIDEODISPLAYHEIGHT:
    977             {
    978                 uint64_t num = ebml_read_uint (s, &l);
    979                 if (num == EBML_UINT_INVALID)
    980                     return 0;
    981                 track->v_dheight = num;
    982                 dprintf ("[mkv] |   + Display height: %u\n",
    983                          track->v_dheight);
    984                 break;
    985             }
    986 
    987         case MATROSKA_ID_VIDEOPIXELWIDTH:
    988             {
    989                 uint64_t num = ebml_read_uint (s, &l);
    990                 if (num == EBML_UINT_INVALID)
    991                     return 0;
    992                 track->v_width = num;
    993                 dprintf ("[mkv] |   + Pixel width: %u\n",
    994                          track->v_width);
    995                 break;
    996             }
    997 
    998         case MATROSKA_ID_VIDEOPIXELHEIGHT:
    999             {
    1000                 uint64_t num = ebml_read_uint (s, &l);
    1001                 if (num == EBML_UINT_INVALID)
    1002                     return 0;
    1003                 track->v_height = num;
    1004                 dprintf ("[mkv] |   + Pixel height: %u\n",
    1005                          track->v_height);
    1006                 break;
    1007             }
    1008 
    1009         default:
    1010             ebml_read_skip (s, &l);
    1011             break;
    1012         }
    1013         length -= l + il;
    1014     }
    1015     return len;
     1014      length -= l + il;
     1015    }
     1016  return len;
    10161017}
    10171018
    … …  
    10221023static void
    10231024demux_mkv_free_trackentry(mkv_track_t *track) {
    1024     if (track->name)
    1025         free (track->name);
    1026     if (track->codec_id)
    1027         free (track->codec_id);
    1028     if (track->language)
    1029         free (track->language);
    1030     if (track->private_data)
    1031         free (track->private_data);
    1032     if (track->audio_buf)
    1033         free (track->audio_buf);
    1034     if (track->audio_timestamp)
    1035         free (track->audio_timestamp);
     1025  if (track->name)
     1026    free (track->name);
     1027  if (track->codec_id)
     1028    free (track->codec_id);
     1029  if (track->language)
     1030    free (track->language);
     1031  if (track->private_data)
     1032    free (track->private_data);
     1033  if (track->audio_buf)
     1034    free (track->audio_buf);
     1035  if (track->audio_timestamp)
     1036    free (track->audio_timestamp);
    10361037#ifdef USE_ASS
    1037     if (track->sh_sub.ass_track)
    1038         ass_free_track (track->sh_sub.ass_track);
     1038  if (track->sh_sub.ass_track)
     1039    ass_free_track (track->sh_sub.ass_track);
    10391040#endif
    1040     demux_mkv_free_encodings(track->encodings, track->num_encodings);
    1041     free(track);
     1041  demux_mkv_free_encodings(track->encodings, track->num_encodings);
     1042  free(track);
    10421043}
    10431044
    … …  
    10451046demux_mkv_read_trackentry (demuxer_t *demuxer)
    10461047{
    1047     mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
    1048     stream_t *s = demuxer->stream;
    1049     mkv_track_t *track;
    1050     uint64_t len, length, l;
    1051     int il;
    1052 
    1053     track = (mkv_track_t *) malloc (sizeof (*track));
    1054     memset(track, 0, sizeof(*track));
    1055     /* set default values */
    1056     track->default_track = 1;
    1057     track->language = strdup("eng");
    1058 
    1059     len = length = ebml_read_length (s, &il);
    1060     len += il;
    1061     while (length > 0)
    1062     {
    1063         switch (ebml_read_id (s, &il))
     1048  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
     1049  stream_t *s = demuxer->stream;
     1050  mkv_track_t *track;
     1051  uint64_t len, length, l;
     1052  int il;
     1053
     1054  track = calloc (1, sizeof (*track));
     1055  /* set default values */
     1056  track->default_track = 1;
     1057  track->name = 0;
     1058  track->language = strdup("eng");
     1059
     1060  len = length = ebml_read_length (s, &il);
     1061  len += il;
     1062  while (length > 0)
     1063    {
     1064      switch (ebml_read_id (s, &il))
    10641065        {
    10651066        case MATROSKA_ID_TRACKNUMBER:
    1066             {
    1067                 uint64_t num = ebml_read_uint (s, &l);
    1068                 if (num == EBML_UINT_INVALID)
    1069                     goto err_out;
    1070                 track->tnum = num;
    1071                 dprintf ("[mkv] |  + Track number: %u\n",
    1072                          track->tnum);
     1067          {
     1068            uint64_t num = ebml_read_uint (s, &l);
     1069            if (num == EBML_UINT_INVALID)
     1070              goto err_out;
     1071            track->tnum = num;
     1072            dprintf("[mkv] |  + Track number: %u\n",
     1073                    track->tnum);
     1074            break;
     1075          }
     1076
     1077        case MATROSKA_ID_TRACKNAME:
     1078          {
     1079            track->name = ebml_read_utf8 (s, &l);
     1080            if (track->name == NULL)
     1081              goto err_out;
     1082            dprintf("[mkv] |  + Name: %s\n",
     1083                    track->name);
     1084            break;
     1085          }
     1086         
     1087        case MATROSKA_ID_TRACKTYPE:
     1088          {
     1089            uint64_t num = ebml_read_uint (s, &l);
     1090            if (num == EBML_UINT_INVALID)
     1091              return 0;
     1092            track->type = num;
     1093            dprintf("[mkv] |  + Track type: ");
     1094            switch (track->type)
     1095              {
     1096              case MATROSKA_TRACK_AUDIO:
     1097                dprintf("Audio\n");
     1098                break;
     1099              case MATROSKA_TRACK_VIDEO:
     1100                dprintf("Video\n");
     1101                break;
     1102              case MATROSKA_TRACK_SUBTITLE:
     1103                dprintf("Subtitle\n");
     1104                break;
     1105              default:
     1106                dprintf("unknown\n");
    10731107                break;
    10741108            }
    1075 
    1076         case MATROSKA_ID_TRACKTYPE:
     1109            break;
     1110          }
     1111
     1112        case MATROSKA_ID_TRACKAUDIO:
     1113          dprintf("[mkv] |  + Audio track\n");
     1114          l = demux_mkv_read_trackaudio (demuxer, track);
     1115          if (l == 0)
     1116            goto err_out;
     1117          break;
     1118
     1119        case MATROSKA_ID_TRACKVIDEO:
     1120          dprintf("[mkv] |  + Video track\n");
     1121          l = demux_mkv_read_trackvideo (demuxer, track);
     1122          if (l == 0)
     1123            goto err_out;
     1124          break;
     1125
     1126        case MATROSKA_ID_CODECID:
     1127          track->codec_id = ebml_read_ascii (s, &l);
     1128          if (track->codec_id == NULL)
     1129            goto err_out;
     1130          if (!strcmp (track->codec_id, MKV_V_MSCOMP) ||
     1131              !strcmp (track->codec_id, MKV_A_ACM))
     1132            track->ms_compat = 1;
     1133          else if (!strcmp (track->codec_id, MKV_S_VOBSUB))
     1134            track->subtitle_type = MATROSKA_SUBTYPE_VOBSUB;
     1135          else if (!strcmp (track->codec_id, MKV_S_TEXTSSA)
     1136                   || !strcmp (track->codec_id, MKV_S_TEXTASS)
     1137                   || !strcmp (track->codec_id, MKV_S_SSA)
     1138                   || !strcmp (track->codec_id, MKV_S_ASS))
    10771139            {
    1078                 uint64_t num = ebml_read_uint (s, &l);
    1079                 if (num == EBML_UINT_INVALID)
    1080                     return 0;
    1081                 track->type = num;
    1082                 dprintf ("[mkv] |  + Track type: ");
    1083                 switch (track->type)
    1084                 {
    1085                 case MATROSKA_TRACK_AUDIO:
    1086                     dprintf ("Audio\n");
    1087                     break;
    1088                 case MATROSKA_TRACK_VIDEO:
    1089                     dprintf ("Video\n");
    1090                     break;
    1091                 case MATROSKA_TRACK_SUBTITLE:
    1092                     dprintf ("Subtitle\n");
    1093                     break;
    1094                 default:
    1095                     dprintf ("unknown\n");
    1096                     break;
    1097                 }
    1098                 break;
     1140              track->subtitle_type = MATROSKA_SUBTYPE_SSA;
    10991141            }
    1100 
    1101         case MATROSKA_ID_TRACKAUDIO:
    1102             dprintf ("[mkv] |  + Audio track\n");
    1103             l = demux_mkv_read_trackaudio (demuxer, track);
    1104             if (l == 0)
    1105                 goto err_out;
     1142          else if (!strcmp (track->codec_id, MKV_S_TEXTASCII))
     1143            track->subtitle_type = MATROSKA_SUBTYPE_TEXT;
     1144          if (!strcmp (track->codec_id, MKV_S_TEXTUTF8))
     1145            {
     1146              track->subtitle_type = MATROSKA_SUBTYPE_TEXT;
     1147            }
     1148          dprintf("[mkv] |  + Codec ID: %s\n",
     1149                  track->codec_id);
     1150          break;
     1151
     1152        case MATROSKA_ID_CODECPRIVATE:
     1153          {
     1154            int x;
     1155            uint64_t num = ebml_read_length (s, &x);
     1156            // audit: cheap guard against overflows later..
     1157            if (num > SIZE_MAX - 1000) return 0;
     1158            l = x + num;
     1159            track->private_data = malloc (num);
     1160            if (stream_read(s, track->private_data, num) != (int) num)
     1161              goto err_out;
     1162            track->private_size = num;
     1163            dprintf("[mkv] |  + CodecPrivate, length "
     1164                    "%u\n", track->private_size);
    11061165            break;
    1107 
    1108         case MATROSKA_ID_TRACKVIDEO:
    1109             dprintf ("[mkv] |  + Video track\n");
    1110             l = demux_mkv_read_trackvideo (demuxer, track);
    1111             if (l == 0)
    1112                 goto err_out;
     1166          }
     1167
     1168        case MATROSKA_ID_TRACKLANGUAGE:
     1169          free(track->language);
     1170          track->language = ebml_read_utf8 (s, &l);
     1171          if (track->language == NULL)
     1172            goto err_out;
     1173          dprintf("[mkv] |  + Language: %s\n",
     1174                  track->language);
     1175          break;
     1176
     1177        case MATROSKA_ID_TRACKFLAGDEFAULT:
     1178          {
     1179            uint64_t num = ebml_read_uint (s, &l);
     1180            if (num == EBML_UINT_INVALID)
     1181              goto err_out;
     1182            track->default_track = num;
     1183            dprintf("[mkv] |  + Default flag: %u\n",
     1184                    track->default_track);
    11131185            break;
    1114 
    1115         case MATROSKA_ID_CODECID:
    1116             track->codec_id = ebml_read_ascii (s, &l);
    1117             if (track->codec_id == NULL)
    1118                 goto err_out;
    1119             if (!strcmp (track->codec_id, MKV_V_MSCOMP) ||
    1120                 !strcmp (track->codec_id, MKV_A_ACM))
    1121                 track->ms_compat = 1;
    1122             else if (!strcmp (track->codec_id, MKV_S_VOBSUB))
    1123                 track->subtitle_type = MATROSKA_SUBTYPE_VOBSUB;
    1124             else if (!strcmp (track->codec_id, MKV_S_TEXTSSA)
    1125                      || !strcmp (track->codec_id, MKV_S_TEXTASS)
    1126                      || !strcmp (track->codec_id, MKV_S_SSA)
    1127                      || !strcmp (track->codec_id, MKV_S_ASS))
    1128             {
    1129                 track->subtitle_type = MATROSKA_SUBTYPE_SSA;
    1130             }
    1131             else if (!strcmp (track->codec_id, MKV_S_TEXTASCII))
    1132                 track->subtitle_type = MATROSKA_SUBTYPE_TEXT;
    1133             if (!strcmp (track->codec_id, MKV_S_TEXTUTF8))
    1134             {
    1135                 track->subtitle_type = MATROSKA_SUBTYPE_TEXT;
    1136             }
    1137             dprintf ("[mkv] |  + Codec ID: %s\n",
    1138                      track->codec_id);
     1186          }
     1187
     1188        case MATROSKA_ID_TRACKDEFAULTDURATION:
     1189          {
     1190            uint64_t num = ebml_read_uint (s, &l);
     1191            if (num == EBML_UINT_INVALID)
     1192              goto err_out;
     1193            if (num == 0)
     1194              dprintf("[mkv] |  + Default duration: 0");
     1195            else
     1196              {
     1197                track->v_frate = 1000000000.0 / num;
     1198                track->default_duration = num / 1000000000.0;
     1199                dprintf("[mkv] |  + Default duration: "
     1200                        "%.3fms ( = %.3f fps)\n",num/1000000.0,track->v_frate);
     1201              }
    11391202            break;
    1140 
    1141         case MATROSKA_ID_CODECPRIVATE:
    1142             {
    1143                 int x;
    1144                 uint64_t num = ebml_read_length (s, &x);
    1145                 // audit: cheap guard against overflows later..
    1146                 if (num > SIZE_MAX - 1000) return 0;
    1147                 l = x + num;
    1148                 track->private_data = malloc (num);
    1149                 if (stream_read(s, track->private_data, num) != (int) num)
    1150                     goto err_out;
    1151                 track->private_size = num;
    1152                 dprintf ("[mkv] |  + CodecPrivate, length "
    1153                          "%u\n", track->private_size);
    1154                 break;
    1155             }
    1156 
    1157         case MATROSKA_ID_TRACKLANGUAGE:
    1158             free(track->language);
    1159             track->language = ebml_read_utf8 (s, &l);
    1160             if (track->language == NULL)
    1161                 goto err_out;
    1162             dprintf ("[mkv] |  + Language: %s\n",
    1163                      track->language);
    1164             break;
    1165 
    1166         case MATROSKA_ID_TRACKFLAGDEFAULT:
    1167             {
    1168                 uint64_t num = ebml_read_uint (s, &l);
    1169                 if (num == EBML_UINT_INVALID)
    1170                     goto err_out;
    1171                 track->default_track = num;
    1172                 dprintf ("[mkv] |  + Default flag: %u\n",
    1173                          track->default_track);
    1174                 break;
    1175             }
    1176 
    1177         case MATROSKA_ID_TRACKDEFAULTDURATION:
    1178             {
    1179                 uint64_t num = ebml_read_uint (s, &l);
    1180                 if (num == EBML_UINT_INVALID)
    1181                     goto err_out;
    1182                 if (num == 0)
    1183                     dprintf ("[mkv] |  + Default duration: 0");
    1184                 else
    1185                 {
    1186                     track->v_frate = 1000000000.0 / num;
    1187                     track->default_duration = num / 1000000000.0;
    1188                     dprintf ("[mkv] |  + Default duration: "
    1189                              "%.3fms ( = %.3f fps)\n",num/1000000.0,track->v_frate);
    1190                 }
    1191                 break;
    1192             }
     1203          }
    11931204
    11941205        case MATROSKA_ID_TRACKENCODINGS:
    1195             l = demux_mkv_read_trackencodings (demuxer, track);
    1196             if (l == 0)
    1197                 goto err_out;
    1198             break;
     1206          l = demux_mkv_read_trackencodings (demuxer, track);
     1207          if (l == 0)
     1208            goto err_out;
     1209          break;
     1210
     1211        default:
     1212          ebml_read_skip (s, &l);
     1213          break;
     1214        }
     1215      length -= l + il;
     1216    }
     1217
     1218  mkv_d->tracks[mkv_d->num_tracks++] = track;
     1219  return len;
     1220
     1221err_out:
     1222  demux_mkv_free_trackentry(track);
     1223  return 0;
     1224}
     1225
     1226static int
     1227demux_mkv_read_tracks (demuxer_t *demuxer)
     1228{
     1229  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
     1230  stream_t *s = demuxer->stream;
     1231  uint64_t length, l;
     1232  int il;
     1233
     1234  mkv_d->tracks = malloc (sizeof (*mkv_d->tracks));
     1235  mkv_d->num_tracks = 0;
     1236
     1237  length = ebml_read_length (s, NULL);
     1238  while (length > 0)
     1239    {
     1240      switch (ebml_read_id (s, &il))
     1241        {
     1242        case MATROSKA_ID_TRACKENTRY:
     1243          dprintf("[mkv] | + a track...\n");
     1244          mkv_d->tracks = realloc (mkv_d->tracks,
     1245                                   (mkv_d->num_tracks+1)
     1246                                   *sizeof (*mkv_d->tracks));
     1247          l = demux_mkv_read_trackentry (demuxer);
     1248          if (l == 0)
     1249            return 1;
     1250          break;
    11991251
    12001252        default:
    … …  
    12021254            break;
    12031255        }
    1204         length -= l + il;
    1205     }
    1206 
    1207     mkv_d->tracks[mkv_d->num_tracks++] = track;
    1208     return len;
    1209 
    1210 err_out:
    1211     demux_mkv_free_trackentry(track);
     1256      length -= l + il;
     1257    }
     1258  return 0;
     1259}
     1260
     1261extern int index_mode;
     1262
     1263static int
     1264demux_mkv_read_cues (demuxer_t *demuxer)
     1265{
     1266  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
     1267  stream_t *s = demuxer->stream;
     1268  uint64_t length, l, time, track, pos;
     1269  off_t off;
     1270  int i, il;
     1271
     1272  if (index_mode == 0) {
     1273    ebml_read_skip (s, NULL);
    12121274    return 0;
     1275  }
     1276  off = stream_tell (s);
     1277  for (i=0; i<mkv_d->parsed_cues_num; i++)
     1278    if (mkv_d->parsed_cues[i] == off)
     1279      {
     1280        ebml_read_skip (s, NULL);
     1281        return 0;
     1282      }
     1283  mkv_d->parsed_cues = realloc (mkv_d->parsed_cues,
     1284                                (mkv_d->parsed_cues_num+1)
     1285                                * sizeof (off_t));
     1286  mkv_d->parsed_cues[mkv_d->parsed_cues_num++] = off;
     1287
     1288  dprintf("[mkv] /---- [ parsing cues ] -----------\n");
     1289  length = ebml_read_length (s, NULL);
     1290
     1291  while (length > 0)
     1292    {
     1293      time = track = pos = EBML_UINT_INVALID;
     1294
     1295      switch (ebml_read_id (s, &il))
     1296        {
     1297        case MATROSKA_ID_POINTENTRY:
     1298          {
     1299            uint64_t len;
     1300
     1301            len = ebml_read_length (s, &i);
     1302            l = len + i;
     1303
     1304            while (len > 0)
     1305              {
     1306                uint64_t l;
     1307                int il;
     1308
     1309                switch (ebml_read_id (s, &il))
     1310                  {
     1311                  case MATROSKA_ID_CUETIME:
     1312                    time = ebml_read_uint (s, &l);
     1313                    break;
     1314
     1315                  case MATROSKA_ID_CUETRACKPOSITION:
     1316                    {
     1317                      uint64_t le;
     1318
     1319                      le = ebml_read_length (s, &i);
     1320                      l = le + i;
     1321
     1322                      while (le > 0)
     1323                        {
     1324                          uint64_t l;
     1325                          int il;
     1326
     1327                          switch (ebml_read_id (s, &il))
     1328                            {
     1329                            case MATROSKA_ID_CUETRACK:
     1330                              track = ebml_read_uint (s, &l);
     1331                              break;
     1332
     1333                            case MATROSKA_ID_CUECLUSTERPOSITION:
     1334                              pos = ebml_read_uint (s, &l);
     1335                              break;
     1336
     1337                            default:
     1338                              ebml_read_skip (s, &l);
     1339                              break;
     1340                            }
     1341                          le -= l + il;
     1342                        }
     1343                      break;
     1344                    }
     1345
     1346                  default:
     1347                    ebml_read_skip (s, &l);
     1348                    break;
     1349                  }
     1350                len -= l + il;
     1351              }
     1352            break;
     1353          }
     1354
     1355        default:
     1356          ebml_read_skip (s, &l);
     1357          break;
     1358        }
     1359
     1360      length -= l + il;
     1361
     1362      if (time != EBML_UINT_INVALID && track != EBML_UINT_INVALID
     1363          && pos != EBML_UINT_INVALID)
     1364        {
     1365          grow_array(&mkv_d->indexes, mkv_d->num_indexes, sizeof(mkv_index_t));
     1366          mkv_d->indexes[mkv_d->num_indexes].tnum = track;
     1367          mkv_d->indexes[mkv_d->num_indexes].timecode = time;
     1368          mkv_d->indexes[mkv_d->num_indexes].filepos =mkv_d->segment_start+pos;
     1369          dprintf("[mkv] |+ found cue point "
     1370                  "for track %"PRIu64": timecode %"PRIu64", filepos: %"PRIu64"\n",
     1371                  track, time, mkv_d->segment_start + pos);
     1372          mkv_d->num_indexes++;
     1373        }
     1374    }
     1375
     1376  dprintf("[mkv] \\---- [ parsing cues ] -----------\n");
     1377  return 0;
    12131378}
    12141379
    12151380static int
    1216 demux_mkv_read_tracks (demuxer_t *demuxer)
    1217 {
    1218     mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
    1219     stream_t *s = demuxer->stream;
    1220     uint64_t length, l;
    1221     int il;
    1222 
    1223     mkv_d->tracks = (mkv_track_t **) malloc (sizeof (*mkv_d->tracks));
    1224     mkv_d->num_tracks = 0;
    1225 
    1226     length = ebml_read_length (s, NULL);
    1227     while (length > 0)
    1228     {
    1229         switch (ebml_read_id (s, &il))
    1230         {
    1231         case MATROSKA_ID_TRACKENTRY:
    1232             dprintf ("[mkv] | + a track...\n");
    1233             mkv_d->tracks = (mkv_track_t **) realloc (mkv_d->tracks,
    1234                                                       (mkv_d->num_tracks+1)
    1235                                                       *sizeof (*mkv_d->tracks));
    1236             l = demux_mkv_read_trackentry (demuxer);
    1237             if (l == 0)
    1238                 return 1;
     1381demux_mkv_read_chapters (demuxer_t *demuxer)
     1382{
     1383  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
     1384  stream_t *s = demuxer->stream;
     1385  uint64_t length, l;
     1386  int il;
     1387
     1388  if (demuxer->chapters)
     1389    {
     1390      ebml_read_skip (s, NULL);
     1391      return 0;
     1392    }
     1393
     1394  dprintf("[mkv] /---- [ parsing chapters ] ---------\n");
     1395  length = ebml_read_length (s, NULL);
     1396
     1397  while (length > 0)
     1398    {
     1399      switch (ebml_read_id (s, &il))
     1400        {
     1401        case MATROSKA_ID_EDITIONENTRY:
     1402          {
     1403            uint64_t len;
     1404            int i;
     1405
     1406            len = ebml_read_length (s, &i);
     1407            l = len + i;
     1408
     1409            while (len > 0)
     1410              {
     1411                uint64_t l;
     1412                int il;
     1413
     1414                switch (ebml_read_id (s, &il))
     1415                  {
     1416                  case MATROSKA_ID_CHAPTERATOM:
     1417                    {
     1418                      uint64_t len, start=0, end=0;
     1419                      char* name = 0;
     1420                      int i;
     1421                      int cid;
     1422
     1423                      len = ebml_read_length (s, &i);
     1424                      l = len + i;
     1425
     1426                      while (len > 0)
     1427                        {
     1428                          uint64_t l;
     1429                          int il;
     1430
     1431                          switch (ebml_read_id (s, &il))
     1432                            {
     1433                            case MATROSKA_ID_CHAPTERTIMESTART:
     1434                              start = ebml_read_uint (s, &l) / 1000000;
     1435                              break;
     1436
     1437                            case MATROSKA_ID_CHAPTERTIMEEND:
     1438                              end = ebml_read_uint (s, &l) / 1000000;
     1439                              break;
     1440
     1441                            case MATROSKA_ID_CHAPTERDISPLAY:
     1442                              {
     1443                                uint64_t len;
     1444                                int i;
     1445
     1446                                len = ebml_read_length (s, &i);
     1447                                l = len + i;
     1448                                while (len > 0)
     1449                                  {
     1450                                    uint64_t l;
     1451                                    int il;
     1452
     1453                                    switch (ebml_read_id (s, &il))
     1454                                      {
     1455                                        case MATROSKA_ID_CHAPSTRING:
     1456                                          name = ebml_read_utf8 (s, &l);
     1457                                          break;
     1458                                        default:
     1459                                          ebml_read_skip (s, &l);
     1460                                          break;
     1461                                      }
     1462                                    len -= l + il;
     1463                                  }
     1464                              }
     1465                              break;
     1466
     1467                            default:
     1468                              ebml_read_skip (s, &l);
     1469                              break;
     1470                            }
     1471                          len -= l + il;
     1472                        }
     1473
     1474                      if (!name)
     1475                        name = strdup("(unnamed)");
     1476                     
     1477                      cid = demuxer_add_chapter(demuxer, name, start, end);
     1478                     
     1479                      dprintf(
     1480                             "[mkv] Chapter %u from %02d:%02d:%02d."
     1481                             "%03d to %02d:%02d:%02d.%03d, %s\n",
     1482                             cid,
     1483                             (int) (start / 60 / 60 / 1000),
     1484                             (int) ((start / 60 / 1000) % 60),
     1485                             (int) ((start / 1000) % 60),
     1486                             (int) (start % 1000),
     1487                             (int) (end / 60 / 60 / 1000),
     1488                             (int) ((end / 60 / 1000) % 60),
     1489                             (int) ((end / 1000) % 60),
     1490                             (int) (end % 1000), name);
     1491
     1492                      free(name);
     1493                      break;
     1494                    }
     1495
     1496                  default:
     1497                    ebml_read_skip (s, &l);
     1498                    break;
     1499                  }
     1500                len -= l + il;
     1501              }
    12391502            break;
     1503          }
     1504
     1505        default:
     1506          ebml_read_skip (s, &l);
     1507          break;
     1508        }
     1509
     1510      length -= l + il;
     1511    }
     1512
     1513  dprintf("[mkv] \\---- [ parsing chapters ] ---------\n");
     1514  return 0;
     1515}
     1516
     1517static int
     1518demux_mkv_read_tags (demuxer_t *demuxer)
     1519{
     1520  ebml_read_skip (demuxer->stream, NULL);
     1521  return 0;
     1522}
     1523
     1524static int
     1525demux_mkv_read_attachments (demuxer_t *demuxer)
     1526{
     1527  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
     1528  stream_t *s = demuxer->stream;
     1529  uint64_t length, l;
     1530  int il;
     1531
     1532  dprintf("[mkv] /---- [ parsing attachments ] ---------\n");
     1533  length = ebml_read_length (s, NULL);
     1534
     1535  while (length > 0)
     1536    {
     1537      switch (ebml_read_id (s, &il))
     1538        {
     1539          case MATROSKA_ID_ATTACHEDFILE:
     1540            {
     1541              uint64_t len;
     1542              int i;
     1543              char* name = NULL;
     1544              char* mime = NULL;
     1545              uint64_t uid = 0;
     1546              char* data = NULL;
     1547              int data_size = 0;
     1548
     1549              len = ebml_read_length (s, &i);
     1550              l = len + i;
     1551
     1552              dprintf("[mkv] | + an attachment...\n");
     1553
     1554              grow_array(&mkv_d->attachments, mkv_d->num_attachments,
     1555                         sizeof(*mkv_d->attachments));
     1556
     1557              while (len > 0)
     1558                {
     1559                  uint64_t l;
     1560                  int il;
     1561
     1562                  switch (ebml_read_id (s, &il))
     1563                    {
     1564                    case MATROSKA_ID_FILENAME:
     1565                      name = ebml_read_utf8 (s, &l);
     1566                      if (name == NULL)
     1567                        return 0;
     1568                      dprintf("[mkv] |  + FileName: %s\n",
     1569                        name);
     1570                      break;
     1571
     1572                    case MATROSKA_ID_FILEMIMETYPE:
     1573                      mime = ebml_read_ascii (s, &l);
     1574                      if (mime == NULL)
     1575                        return 0;
     1576                      dprintf("[mkv] |  + FileMimeType: %s\n",
     1577                        mime);
     1578                      break;
     1579
     1580                    case MATROSKA_ID_FILEUID:
     1581                      uid = ebml_read_uint (s, &l);
     1582                      break;
     1583
     1584                    case MATROSKA_ID_FILEDATA:
     1585                      {
     1586                        int x;
     1587                        uint64_t num = ebml_read_length (s, &x);
     1588                        l = x + num;
     1589                        free(data);
     1590                        data = malloc (num);
     1591                        if (stream_read(s, data, num) != (int) num)
     1592                        {
     1593                          free(data);
     1594                          return 0;
     1595                        }
     1596                        data_size = num;
     1597                        dprintf("[mkv] |  + FileData, length "
     1598                                "%u\n", data_size);
     1599                        break;
     1600                      }
     1601
     1602                    default:
     1603                      ebml_read_skip (s, &l);
     1604                      break;
     1605                    }
     1606                  len -= l + il;
     1607                }
     1608
     1609              mkv_d->attachments[mkv_d->num_attachments].name = name;
     1610              mkv_d->attachments[mkv_d->num_attachments].mime = mime;
     1611              mkv_d->attachments[mkv_d->num_attachments].uid = uid;
     1612              mkv_d->attachments[mkv_d->num_attachments].data = data;
     1613              mkv_d->attachments[mkv_d->num_attachments].data_size = data_size;
     1614              mkv_d->num_attachments ++;
     1615              dprintf("[mkv] Attachment: %s, %s, %u bytes\n",
     1616                     name, mime, data_size);
     1617#ifdef USE_ASS
     1618              if (extract_embedded_fonts && name && data && data_size &&
     1619                  mime && (strcmp(mime, "application/x-truetype-font") == 0 ||
     1620                  strcmp(mime, "application/x-font") == 0))
     1621                ass_process_font(ass_library, name, data, data_size);
     1622#endif
     1623              break;
     1624            }
     1625
     1626          default:
     1627            ebml_read_skip (s, &l);
     1628            break;
     1629        }
     1630      length -= l + il;
     1631    }
     1632
     1633  dprintf("[mkv] \\---- [ parsing attachments ] ---------\n");
     1634  return 0;
     1635}
     1636
     1637static int
     1638demux_mkv_read_seekhead (demuxer_t *demuxer)
     1639{
     1640  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
     1641  stream_t *s = demuxer->stream;
     1642  uint64_t length, l, seek_pos, saved_pos, num;
     1643  uint32_t seek_id;
     1644  int i, il, res = 0;
     1645  off_t off;
     1646
     1647  off = stream_tell (s);
     1648  for (i=0; i<mkv_d->parsed_seekhead_num; i++)
     1649    if (mkv_d->parsed_seekhead[i] == off)
     1650      {
     1651        ebml_read_skip (s, NULL);
     1652        return 0;
     1653      }
     1654  mkv_d->parsed_seekhead = realloc (mkv_d->parsed_seekhead,
     1655                                    (mkv_d->parsed_seekhead_num+1)
     1656                                    * sizeof (off_t));
     1657  mkv_d->parsed_seekhead[mkv_d->parsed_seekhead_num++] = off;
     1658
     1659  dprintf("[mkv] /---- [ parsing seek head ] ---------\n");
     1660  length = ebml_read_length (s, NULL);
     1661  /* off now holds the position of the next element after the seek head. */
     1662  off = stream_tell (s) + length;
     1663  while (length > 0 && !res)
     1664    {
     1665
     1666      seek_id = 0;
     1667      seek_pos = EBML_UINT_INVALID;
     1668
     1669      switch (ebml_read_id (s, &il))
     1670        {
     1671        case MATROSKA_ID_SEEKENTRY:
     1672          {
     1673            uint64_t len;
     1674
     1675            len = ebml_read_length (s, &i);
     1676            l = len + i;
     1677
     1678            while (len > 0)
     1679              {
     1680                uint64_t l;
     1681                int il;
     1682
     1683                switch (ebml_read_id (s, &il))
     1684                  {
     1685                  case MATROSKA_ID_SEEKID:
     1686                    num = ebml_read_uint (s, &l);
     1687                    if (num != EBML_UINT_INVALID)
     1688                      seek_id = num;
     1689                    break;
     1690
     1691                  case MATROSKA_ID_SEEKPOSITION:
     1692                    seek_pos = ebml_read_uint (s, &l);
     1693                    break;
     1694
     1695                  default:
     1696                    ebml_read_skip (s, &l);
     1697                    break;
     1698                  }
     1699                len -= l + il;
     1700              }
     1701
     1702            break;
     1703          }
    12401704
    12411705        default:
    … …  
    12431707            break;
    12441708        }
    1245         length -= l + il;
    1246     }
    1247     return 0;
    1248 }
    1249 
    1250 extern int index_mode;
     1709      length -= l + il;
     1710
     1711      if (seek_id == 0 || seek_id == MATROSKA_ID_CLUSTER
     1712          || seek_pos == EBML_UINT_INVALID ||
     1713          ((mkv_d->segment_start + seek_pos) >= (uint64_t)demuxer->movi_end))
     1714        continue;
     1715
     1716      saved_pos = stream_tell (s);
     1717      if (!stream_seek (s, mkv_d->segment_start + seek_pos))
     1718        res = 1;
     1719      else
     1720        {
     1721          if (ebml_read_id (s, &il) != seek_id)
     1722            res = 1;
     1723          else
     1724            switch (seek_id)
     1725              {
     1726              case MATROSKA_ID_CUES:
     1727                if (demux_mkv_read_cues (demuxer))
     1728                  res = 1;
     1729                break;
     1730
     1731              case MATROSKA_ID_TAGS:
     1732                if (demux_mkv_read_tags (demuxer))
     1733                  res = 1;
     1734                break;
     1735
     1736              case MATROSKA_ID_SEEKHEAD:
     1737                if (demux_mkv_read_seekhead (demuxer))
     1738                  res = 1;
     1739                break;
     1740
     1741              case MATROSKA_ID_CHAPTERS:
     1742                if (demux_mkv_read_chapters (demuxer))
     1743                  res = 1;
     1744                break;
     1745              }
     1746        }
     1747
     1748      stream_seek (s, saved_pos);
     1749    }
     1750  if (res)
     1751    {
     1752      /* If there was an error then try to skip this seek head. */
     1753      if (stream_seek (s, off))
     1754        res = 0;
     1755    }
     1756  else
     1757  if (length > 0)
     1758     stream_seek (s, stream_tell (s) + length);
     1759  dprintf("[mkv] \\---- [ parsing seek head ] ---------\n");
     1760  return res;
     1761}
    12511762
    12521763static int
    1253 demux_mkv_read_cues (demuxer_t *demuxer)
    1254 {
    1255     mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
    1256     stream_t *s = demuxer->stream;
    1257     uint64_t length, l, time, track, pos;
    1258     off_t off;
    1259     int i, il;
    1260 
    1261     if (index_mode == 0) {
    1262         ebml_read_skip (s, NULL);
    1263         return 0;
    1264     }
    1265 
    1266     off = stream_tell (s);
    1267     for (i=0; i<mkv_d->parsed_cues_num; i++)
    1268         if (mkv_d->parsed_cues[i] == off)
    1269         {
    1270             ebml_read_skip (s, NULL);
    1271             return 0;
    1272         }
    1273     mkv_d->parsed_cues = (off_t *) realloc (mkv_d->parsed_cues,
    1274                                             (mkv_d->parsed_cues_num+1)
    1275                                             * sizeof (off_t));
    1276     mkv_d->parsed_cues[mkv_d->parsed_cues_num++] = off;
    1277 
    1278     dprintf ("[mkv] /---- [ parsing cues ] -----------\n");
    1279     length = ebml_read_length (s, NULL);
    1280 
    1281     while (length > 0)
    1282     {
    1283         time = track = pos = EBML_UINT_INVALID;
    1284 
    1285         switch (ebml_read_id (s, &il))
    1286         {
    1287         case MATROSKA_ID_POINTENTRY:
     1764demux_mkv_open_video (demuxer_t *demuxer, mkv_track_t *track, int vid);
     1765static int
     1766demux_mkv_open_audio (demuxer_t *demuxer, mkv_track_t *track, int aid);
     1767static int
     1768demux_mkv_open_sub (demuxer_t *demuxer, mkv_track_t *track, int sid);
     1769
     1770static void
     1771display_create_tracks (demuxer_t *demuxer)
     1772{
     1773  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *)demuxer->priv;
     1774  int i, vid=0, aid=0, sid=0;
     1775
     1776  for (i=0; i<mkv_d->num_tracks; i++)
     1777    {
     1778      char *type = "unknown", str[32];
     1779      *str = '\0';
     1780      switch (mkv_d->tracks[i]->type)
     1781        {
     1782        case MATROSKA_TRACK_VIDEO:
     1783          type = "video";
     1784          demux_mkv_open_video(demuxer, mkv_d->tracks[i], vid);
     1785          if (mkv_d->tracks[i]->name)
     1786            dprintf("ID_VID_%d_NAME=%s\n", vid, mkv_d->tracks[i]->name);
     1787          sprintf (str, "-vid %u", vid++);
     1788          break;
     1789        case MATROSKA_TRACK_AUDIO:
     1790          type = "audio";
     1791          demux_mkv_open_audio(demuxer, mkv_d->tracks[i], aid);
     1792          if (mkv_d->tracks[i]->name)
     1793            dprintf("ID_AID_%d_NAME=%s\n", aid, mkv_d->tracks[i]->name);
     1794          dprintf("ID_AID_%d_LANG=%s\n", aid, mkv_d->tracks[i]->language);
     1795          sprintf (str, "-aid %u, -alang %.5s",aid++,mkv_d->tracks[i]->language);
     1796          break;
     1797        case MATROSKA_TRACK_SUBTITLE:
     1798          type = "subtitles";
     1799          demux_mkv_open_sub(demuxer, mkv_d->tracks[i], sid);
     1800          if (mkv_d->tracks[i]->name)
     1801            dprintf("ID_SID_%d_NAME=%s\n", sid, mkv_d->tracks[i]->name);
     1802          dprintf("ID_SID_%d_LANG=%s\n", sid, mkv_d->tracks[i]->language);
     1803          sprintf (str, "-sid %u, -slang %.5s",sid++,mkv_d->tracks[i]->language);
     1804          break;
     1805        }
     1806      if (mkv_d->tracks[i]->name)
     1807        dprintf( MSGTR_MPDEMUX_MKV_TrackIDName,
     1808             mkv_d->tracks[i]->tnum, type, mkv_d->tracks[i]->codec_id, mkv_d->tracks[i]->name, str);
     1809      else
     1810        dprintf( MSGTR_MPDEMUX_MKV_TrackID,
     1811             mkv_d->tracks[i]->tnum, type, mkv_d->tracks[i]->codec_id, str);
     1812    }
     1813}
     1814
     1815static int
     1816demux_mkv_open_video (demuxer_t *demuxer, mkv_track_t *track, int vid)
     1817{
     1818  BITMAPINFOHEADERw *bih;
     1819  void *ImageDesc = NULL;
     1820  sh_video_t *sh_v;
     1821
     1822  if (track->ms_compat)  /* MS compatibility mode */
     1823    {
     1824      BITMAPINFOHEADERw *src;
     1825
     1826      if (track->private_data == NULL
     1827          || track->private_size < sizeof (BITMAPINFOHEADERw))
     1828        return 1;
     1829
     1830      src = (BITMAPINFOHEADERw *) track->private_data;
     1831      bih = calloc (1, track->private_size);
     1832      bih->biSize = le2me_32 (src->biSize);
     1833      bih->biWidth = le2me_32 (src->biWidth);
     1834      bih->biHeight = le2me_32 (src->biHeight);
     1835      bih->biPlanes = le2me_16 (src->biPlanes);
     1836      bih->biBitCount = le2me_16 (src->biBitCount);
     1837      bih->biCompression = le2me_32 (src->biCompression);
     1838      bih->biSizeImage = le2me_32 (src->biSizeImage);
     1839      bih->biXPelsPerMeter = le2me_32 (src->biXPelsPerMeter);
     1840      bih->biYPelsPerMeter = le2me_32 (src->biYPelsPerMeter);
     1841      bih->biClrUsed = le2me_32 (src->biClrUsed);
     1842      bih->biClrImportant = le2me_32 (src->biClrImportant);
     1843      memcpy((char *) bih + sizeof (BITMAPINFOHEADERw),
     1844             (char *) src + sizeof (BITMAPINFOHEADERw),
     1845             track->private_size - sizeof (BITMAPINFOHEADERw));
     1846
     1847      if (track->v_width == 0)
     1848        track->v_width = bih->biWidth;
     1849      if (track->v_height == 0)
     1850        track->v_height = bih->biHeight;
     1851    }
     1852  else
     1853    {
     1854      bih = calloc (1, sizeof (BITMAPINFOHEADERw));
     1855      bih->biSize = sizeof (BITMAPINFOHEADERw);
     1856      bih->biWidth = track->v_width;
     1857      bih->biHeight = track->v_height;
     1858      bih->biBitCount = 24;
     1859      bih->biSizeImage = bih->biWidth * bih->biHeight * bih->biBitCount/8;
     1860
     1861      if (track->private_size >= sizeof (real_video_props_t)
     1862          && (!strcmp (track->codec_id, MKV_V_REALV10)
     1863              || !strcmp (track->codec_id, MKV_V_REALV20)
     1864              || !strcmp (track->codec_id, MKV_V_REALV30)
     1865              || !strcmp (track->codec_id, MKV_V_REALV40)))
     1866        {
     1867          unsigned char *dst, *src;
     1868          real_video_props_t *rvp;
     1869          uint32_t type2;
     1870          unsigned int cnt;
     1871
     1872          rvp = (real_video_props_t *) track->private_data;
     1873          src = (unsigned char *) (rvp + 1);
     1874
     1875          cnt = track->private_size - sizeof (real_video_props_t);
     1876          bih = realloc(bih, sizeof (BITMAPINFOHEADERw)+8+cnt);
     1877          bih->biSize = 48+cnt;
     1878          bih->biPlanes = 1;
     1879          type2 = be2me_32 (rvp->type2);
     1880          if (type2 == 0x10003000 || type2 == 0x10003001)
     1881            bih->biCompression=mmioFOURCC('R','V','1','3');
     1882          else
     1883            bih->biCompression=mmioFOURCC('R','V',track->codec_id[9],'0');
     1884          dst = (unsigned char *) (bih + 1);
     1885          ((unsigned int *) dst)[0] = rvp->type1;
     1886          ((unsigned int *) dst)[1] = rvp->type2;
     1887          stream_read(demuxer->stream, dst+8, cnt);
     1888          track->realmedia = 1;
     1889
     1890#ifdef USE_QTX_CODECS
     1891        }
     1892      else if (track->private_size >= sizeof (ImageDescription)
     1893               && !strcmp(track->codec_id, MKV_V_QUICKTIME))
     1894        {
     1895          ImageDescriptionPtr idesc;
     1896
     1897          idesc = (ImageDescriptionPtr) track->private_data;
     1898          idesc->idSize = be2me_32 (idesc->idSize);
     1899          idesc->cType = be2me_32 (idesc->cType);
     1900          idesc->version = be2me_16 (idesc->version);
     1901          idesc->revisionLevel = be2me_16 (idesc->revisionLevel);
     1902          idesc->vendor = be2me_32 (idesc->vendor);
     1903          idesc->temporalQuality = be2me_32 (idesc->temporalQuality);
     1904          idesc->spatialQuality = be2me_32 (idesc->spatialQuality);
     1905          idesc->width = be2me_16 (idesc->width);
     1906          idesc->height = be2me_16 (idesc->height);
     1907          idesc->hRes = be2me_32 (idesc->hRes);
     1908          idesc->vRes = be2me_32 (idesc->vRes);
     1909          idesc->dataSize = be2me_32 (idesc->dataSize);
     1910          idesc->frameCount = be2me_16 (idesc->frameCount);
     1911          idesc->depth = be2me_16 (idesc->depth);
     1912          idesc->clutID = be2me_16 (idesc->clutID);
     1913          bih->biPlanes = 1;
     1914          bih->biCompression = idesc->cType;
     1915          ImageDesc = idesc;
     1916#endif /* USE_QTX_CODECS */
     1917
     1918        }
     1919      else if (!strcmp(track->codec_id, MKV_V_MPEG1))
     1920        {
     1921          bih->biCompression = mmioFOURCC('m', 'p', 'g', '1');
     1922          track->reorder_timecodes = !correct_pts;
     1923        }
     1924      else if (!strcmp(track->codec_id, MKV_V_MPEG2))
     1925        {
     1926          bih->biCompression = mmioFOURCC('m', 'p', 'g', '2');
     1927          track->reorder_timecodes = !correct_pts;
     1928        }
     1929      else if (!strcmp(track->codec_id, MKV_V_MPEG4_SP) ||
     1930               !strcmp(track->codec_id, MKV_V_MPEG4_ASP) ||
     1931               !strcmp(track->codec_id, MKV_V_MPEG4_AP))
     1932        {
     1933          bih->biCompression = mmioFOURCC('m', 'p', '4', 'v');
     1934          if (track->private_data && (track->private_size > 0))
    12881935            {
    1289                 uint64_t len;
    1290 
    1291                 len = ebml_read_length (s, &i);
    1292                 l = len + i;
    1293 
    1294                 while (len > 0)
    1295                 {
    1296                     uint64_t l;
    1297                     int il;
    1298 
    1299                     switch (ebml_read_id (s, &il))
    1300                     {
    1301                     case MATROSKA_ID_CUETIME:
    1302                         time = ebml_read_uint (s, &l);
    1303                         break;
    1304 
    1305                     case MATROSKA_ID_CUETRACKPOSITION:
    1306                         {
    1307                             uint64_t le;
    1308 
    1309                             le = ebml_read_length (s, &i);
    1310                             l = le + i;
    1311 
    1312                             while (le > 0)
    1313                             {
    1314                                 uint64_t l;
    1315                                 int il;
    1316 
    1317                                 switch (ebml_read_id (s, &il))
    1318                                 {
    1319                                 case MATROSKA_ID_CUETRACK:
    1320                                     track = ebml_read_uint (s, &l);
    1321                                     break;
    1322 
    1323                                 case MATROSKA_ID_CUECLUSTERPOSITION:
    1324                                     pos = ebml_read_uint (s, &l);
    1325                                     break;
    1326 
    1327                                 default:
    1328                                     ebml_read_skip (s, &l);
    1329                                     break;
    1330                                 }
    1331                                 le -= l + il;
    1332                             }
    1333                             break;
    1334                         }
    1335 
    1336                     default:
    1337                         ebml_read_skip (s, &l);
    1338                         break;
    1339                     }
    1340                     len -= l + il;
    1341                 }
    1342                 break;
     1936              bih->biSize += track->private_size;
     1937              bih = realloc (bih, bih->biSize);
     1938              memcpy (bih + 1, track->private_data, track->private_size);
    13431939            }
    1344 
    1345         default:
    1346             ebml_read_skip (s, &l);
    1347             break;
    1348         }
    1349 
    1350         length -= l + il;
    1351 
    1352         if (time != EBML_UINT_INVALID && track != EBML_UINT_INVALID
    1353             && pos != EBML_UINT_INVALID)
    1354         {
    1355             grow_array(&mkv_d->indexes, mkv_d->num_indexes, sizeof(mkv_index_t));
    1356             mkv_d->indexes[mkv_d->num_indexes].tnum = track;
    1357             mkv_d->indexes[mkv_d->num_indexes].timecode = time;
    1358             mkv_d->indexes[mkv_d->num_indexes].filepos =mkv_d->segment_start+pos;
    1359             dprintf ( "[mkv] |+ found cue point "
    1360                      "for track %"PRIu64": timecode %"PRIu64", filepos: %"PRIu64"\n",
    1361                      track, time, mkv_d->segment_start + pos);
    1362             mkv_d->num_indexes++;
    1363         }
    1364     }
    1365 
    1366     dprintf ("[mkv] \\---- [ parsing cues ] -----------\n");
    1367     return 0;
     1940          track->reorder_timecodes = !correct_pts;
     1941        }
     1942      else if (!strcmp(track->codec_id, MKV_V_MPEG4_AVC))
     1943        {
     1944          bih->biCompression = mmioFOURCC('a', 'v', 'c', '1');
     1945          if (track->private_data && (track->private_size > 0))
     1946            {
     1947              bih->biSize += track->private_size;
     1948              bih = realloc (bih, bih->biSize);
     1949              memcpy (bih + 1, track->private_data, track->private_size);
     1950            }
     1951          track->reorder_timecodes = !correct_pts;
     1952        }
     1953      else
     1954        {
     1955          dprintf(MSGTR_MPDEMUX_MKV_UnknownCodecID,
     1956                  track->codec_id, track->tnum);
     1957          free(bih);
     1958          return 1;
     1959        }
     1960    }
     1961
     1962  sh_v = new_sh_video_vid (demuxer, track->tnum, vid);
     1963  sh_v->bih = bih;
     1964  sh_v->format = sh_v->bih->biCompression;
     1965  if (track->v_frate == 0.0)
     1966    track->v_frate = 25.0;
     1967  sh_v->fps = track->v_frate;
     1968  sh_v->frametime = 1 / track->v_frate;
     1969  sh_v->aspect = 0;
     1970  if (!track->realmedia)
     1971    {
     1972      sh_v->disp_w = track->v_width;
     1973      sh_v->disp_h = track->v_height;
     1974      if (track->v_dheight)
     1975      sh_v->aspect = (float)track->v_dwidth / (float)track->v_dheight;
     1976    }
     1977  else
     1978    {
     1979      // vd_realvid.c will set aspect to disp_w/disp_h and rederive
     1980      // disp_w and disp_h from the RealVideo stream contents returned
     1981      // by the Real DLLs. If DisplayWidth/DisplayHeight was not set in
     1982      // the Matroska file then it has already been set to PixelWidth/Height
     1983      // by check_track_information.
     1984      sh_v->disp_w = track->v_dwidth;
     1985      sh_v->disp_h = track->v_dheight;
     1986    }
     1987  sh_v->ImageDesc = ImageDesc;
     1988  dprintf("[mkv] Aspect: %f\n", sh_v->aspect);
     1989
     1990  sh_v->ds = demuxer->video;
     1991  return 0;
    13681992}
    13691993
    13701994static int
    1371 demux_mkv_read_chapters (demuxer_t *demuxer)
    1372 {
    1373     mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
    1374     stream_t *s = demuxer->stream;
    1375     uint64_t length, l;
    1376     int il;
    1377 
    1378     if (demuxer->chapters)
    1379     {
    1380         ebml_read_skip (s, NULL);
    1381         return 0;
    1382     }
    1383 
    1384     dprintf("[mkv] /---- [ parsing chapters ] ---------\n");
    1385     length = ebml_read_length (s, NULL);
    1386 
    1387     while (length > 0)
    1388     {
    1389         switch (ebml_read_id (s, &il))
    1390         {
    1391         case MATROSKA_ID_EDITIONENTRY:
     1995demux_mkv_open_audio (demuxer_t *demuxer, mkv_track_t *track, int aid)
     1996{
     1997  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
     1998  sh_audio_t *sh_a = new_sh_audio_aid(demuxer, track->tnum, aid);
     1999  demux_packet_t *dp;
     2000  if(!sh_a) return 1;
     2001  mkv_d->audio_tracks[mkv_d->last_aid] = track->tnum;
     2002
     2003  sh_a->ds = demuxer->audio;
     2004  sh_a->wf = malloc (sizeof (WAVEFORMATEX));
     2005  if (track->ms_compat && (track->private_size >= sizeof(WAVEFORMATEX)))
     2006    {
     2007      WAVEFORMATEX *wf = (WAVEFORMATEX *)track->private_data;
     2008      sh_a->wf = realloc(sh_a->wf, track->private_size);
     2009      sh_a->wf->wFormatTag = le2me_16 (wf->wFormatTag);
     2010      sh_a->wf->nChannels = le2me_16 (wf->nChannels);
     2011      sh_a->wf->nSamplesPerSec = le2me_32 (wf->nSamplesPerSec);
     2012      sh_a->wf->nAvgBytesPerSec = le2me_32 (wf->nAvgBytesPerSec);
     2013      sh_a->wf->nBlockAlign = le2me_16 (wf->nBlockAlign);
     2014      sh_a->wf->wBitsPerSample = le2me_16 (wf->wBitsPerSample);
     2015      sh_a->wf->cbSize = track->private_size - sizeof(WAVEFORMATEX);
     2016      memcpy(sh_a->wf + 1, wf + 1, track->private_size - sizeof(WAVEFORMATEX));
     2017      if (track->a_sfreq == 0.0)
     2018        track->a_sfreq = sh_a->wf->nSamplesPerSec;
     2019      if (track->a_channels == 0)
     2020        track->a_channels = sh_a->wf->nChannels;
     2021      if (track->a_bps == 0)
     2022        track->a_bps = sh_a->wf->wBitsPerSample;
     2023      track->a_formattag = sh_a->wf->wFormatTag;
     2024    }
     2025  else
     2026    {
     2027      memset(sh_a->wf, 0, sizeof (WAVEFORMATEX));
     2028      if (!strcmp(track->codec_id, MKV_A_MP3) ||
     2029          !strcmp(track->codec_id, MKV_A_MP2))
     2030        track->a_formattag = 0x0055;
     2031      else if (!strncmp(track->codec_id, MKV_A_AC3, strlen(MKV_A_AC3)))
     2032        track->a_formattag = 0x2000;
     2033      else if (!strcmp(track->codec_id, MKV_A_DTS))
     2034        track->a_formattag = 0x2001;
     2035      else if (!strcmp(track->codec_id, MKV_A_PCM) ||
     2036               !strcmp(track->codec_id, MKV_A_PCM_BE))
     2037        track->a_formattag = 0x0001;
     2038      else if (!strcmp(track->codec_id, MKV_A_AAC_2MAIN) ||
     2039               !strncmp(track->codec_id, MKV_A_AAC_2LC,
     2040                        strlen(MKV_A_AAC_2LC)) ||
     2041               !strcmp(track->codec_id, MKV_A_AAC_2SSR) ||
     2042               !strcmp(track->codec_id, MKV_A_AAC_4MAIN) ||
     2043               !strncmp(track->codec_id, MKV_A_AAC_4LC,
     2044                        strlen(MKV_A_AAC_4LC)) ||
     2045               !strcmp(track->codec_id, MKV_A_AAC_4SSR) ||
     2046               !strcmp(track->codec_id, MKV_A_AAC_4LTP) ||
     2047               !strcmp(track->codec_id, MKV_A_AAC))
     2048        track->a_formattag = mmioFOURCC('M', 'P', '4', 'A');
     2049      else if (!strcmp(track->codec_id, MKV_A_VORBIS))
     2050        {
     2051          if (track->private_data == NULL)
     2052            return 1;
     2053          track->a_formattag = mmioFOURCC('v', 'r', 'b', 's');
     2054        }
     2055      else if (!strcmp(track->codec_id, MKV_A_QDMC))
     2056        track->a_formattag = mmioFOURCC('Q', 'D', 'M', 'C');
     2057      else if (!strcmp(track->codec_id, MKV_A_QDMC2))
     2058        track->a_formattag = mmioFOURCC('Q', 'D', 'M', '2');
     2059      else if (!strcmp(track->codec_id, MKV_A_FLAC))
     2060        {
     2061          if (track->private_data == NULL || track->private_size == 0)
    13922062            {
    1393                 uint64_t len;
    1394                 int i;
    1395 
    1396                 len = ebml_read_length (s, &i);
    1397                 l = len + i;
    1398 
    1399                 while (len > 0)
    1400                 {
    1401                     uint64_t l;
    1402                     int il;
    1403 
    1404                     switch (ebml_read_id (s, &il))
    1405                     {
    1406                     case MATROSKA_ID_CHAPTERATOM:
    1407                         {
    1408                             uint64_t len, start=0, end=0;
    1409                             char* name = 0;
    1410                             int i;
    1411                             int cid;
    1412 
    1413                             len = ebml_read_length (s, &i);
    1414                             l = len + i;
    1415 
    1416                             while (len > 0)
    1417                             {
    1418                                 uint64_t l;
    1419                                 int il;
    1420 
    1421                                 switch (ebml_read_id (s, &il))
    1422                                 {
    1423                                 case MATROSKA_ID_CHAPTERTIMESTART:
    1424                                     start = ebml_read_uint (s, &l) / 1000000;
    1425                                     break;
    1426 
    1427                                 case MATROSKA_ID_CHAPTERTIMEEND:
    1428                                     end = ebml_read_uint (s, &l) / 1000000;
    1429                                     break;
    1430                                 case MATROSKA_ID_CHAPTERDISPLAY:
    1431                                     {
    1432                                         uint64_t len;
    1433                                         int i;
    1434 
    1435                                         len = ebml_read_length (s, &i);
    1436                                         l = len + i;
    1437                                         while (len > 0)
    1438                                         {
    1439                                             uint64_t l;
    1440                                             int il;
    1441 
    1442                                             switch (ebml_read_id (s, &il))
    1443                                             {
    1444                                             case MATROSKA_ID_CHAPSTRING:
    1445                                                 name = ebml_read_utf8 (s, &l);
    1446                                                 break;
    1447                                             default:
    1448                                                 ebml_read_skip (s, &l);
    1449                                                 break;
    1450                                             }
    1451                                             len -= l + il;
    1452                                         }
    1453                                     }
    1454                                     break;
    1455 
    1456                                 default:
    1457                                     ebml_read_skip (s, &l);
    1458                                     break;
    1459                                 }
    1460                                 len -= l + il;
    1461                             }
    1462 
    1463                             if (!name)
    1464                                 name = strdup("(unnamed)");
    1465                             cid = demuxer_add_chapter(demuxer, name, start, end);
    1466 
    1467                             dprintf("[mkv] Chapter %u from %02d:%02d:%02d."
    1468                                     "%03d to %02d:%02d:%02d.%03d, %s\n",
    1469                                     cid,
    1470                                     (int) (start / 60 / 60 / 1000),
    1471                                     (int) ((start / 60 / 1000) % 60),
    1472                                     (int) ((start / 1000) % 60),
    1473                                     (int) (start % 1000),
    1474                                     (int) (end / 60 / 60 / 1000),
    1475                                     (int) ((end / 60 / 1000) % 60),
    1476                                     (int) ((end / 1000) % 60),
    1477                                     (int) (end % 1000), name);
    1478                             free(name);
    1479                             break;
    1480                         }
    1481 
    1482                     default:
    1483                         ebml_read_skip (s, &l);
    1484                         break;
    1485                     }
    1486                     len -= l + il;
    1487                 }
    1488                 break;
     2063              dprintf(
     2064                      MSGTR_MPDEMUX_MKV_FlacTrackDoesNotContainValidHeaders);
     2065              return 1;
    14892066            }
    1490 
    1491         default:
    1492             ebml_read_skip (s, &l);
    1493             break;
    1494         }
    1495 
    1496         length -= l + il;
    1497     }
    1498 
    1499     dprintf("[mkv] \\---- [ parsing chapters ] ---------\n");
    1500     return 0;
    1501 }
    1502 
    1503 static int
    1504 demux_mkv_read_tags (demuxer_t *demuxer)
    1505 {
    1506     ebml_read_skip (demuxer->stream, NULL);
    1507     return 0;
    1508 }
    1509 
    1510 static int
    1511 demux_mkv_read_seekhead (demuxer_t *demuxer)
    1512 {
    1513     mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
    1514     stream_t *s = demuxer->stream;
    1515     uint64_t length, l, seek_pos, saved_pos, num;
    1516     uint32_t seek_id;
    1517     int i, il, res = 0;
    1518     off_t off;
    1519 
    1520     off = stream_tell (s);
    1521     for (i=0; i<mkv_d->parsed_seekhead_num; i++)
    1522         if (mkv_d->parsed_seekhead[i] == off)
    1523         {
    1524             ebml_read_skip (s, NULL);
    1525             return 0;
    1526         }
    1527     mkv_d->parsed_seekhead = (off_t *) realloc (mkv_d->parsed_seekhead,
    1528                                                 (mkv_d->parsed_seekhead_num+1)
    1529                                                 * sizeof (off_t));
    1530     mkv_d->parsed_seekhead[mkv_d->parsed_seekhead_num++] = off;
    1531 
    1532     dprintf("[mkv] /---- [ parsing seek head ] ---------\n");
    1533     length = ebml_read_length (s, NULL);
    1534     while (length > 0 && !res)
    1535     {
    1536 
    1537         seek_id = 0;
    1538         seek_pos = EBML_UINT_INVALID;
    1539 
    1540         switch (ebml_read_id (s, &il))
    1541         {
    1542         case MATROSKA_ID_SEEKENTRY:
    1543             {
    1544                 uint64_t len;
    1545 
    1546                 len = ebml_read_length (s, &i);
    1547                 l = len + i;
    1548 
    1549                 while (len > 0)
    1550                 {
    1551                     uint64_t l;
    1552                     int il;
    1553 
    1554                     switch (ebml_read_id (s, &il))
    1555                     {
    1556                     case MATROSKA_ID_SEEKID:
    1557                         num = ebml_read_uint (s, &l);
    1558                         if (num != EBML_UINT_INVALID)
    1559                             seek_id = num;
    1560                         break;
    1561 
    1562                     case MATROSKA_ID_SEEKPOSITION:
    1563                         seek_pos = ebml_read_uint (s, &l);
    1564                         break;
    1565 
    1566                     default:
    1567                         ebml_read_skip (s, &l);
    1568                         break;
    1569                     }
    1570                     len -= l + il;
    1571                 }
    1572 
    1573                 break;
    1574             }
    1575 
    1576         default:
    1577             ebml_read_skip (s, &l);
    1578             break;
    1579         }
    1580         length -= l + il;
    1581 
    1582         if (seek_id == 0 || seek_id == MATROSKA_ID_CLUSTER
    1583             || seek_pos == EBML_UINT_INVALID ||
    1584             ((mkv_d->segment_start + seek_pos) >= (uint64_t)demuxer->movi_end))
    1585             continue;
    1586 
    1587         saved_pos = stream_tell (s);
    1588         if (!stream_seek (s, mkv_d->segment_start + seek_pos))
    1589             res = 1;
    1590         else
    1591         {
    1592             if (ebml_read_id (s, &il) != seek_id)
    1593                 res = 1;
    1594             else
    1595                 switch (seek_id)
    1596                 {
    1597                 case MATROSKA_ID_CUES:
    1598                     if (demux_mkv_read_cues (demuxer))
    1599                         res = 1;
    1600                     break;
    1601 
    1602                 case MATROSKA_ID_TAGS:
    1603                     if (demux_mkv_read_tags (demuxer))
    1604                         res = 1;
    1605                     break;
    1606 
    1607                 case MATROSKA_ID_SEEKHEAD:
    1608                     if (demux_mkv_read_seekhead (demuxer))
    1609                         res = 1;
    1610                     break;
    1611 
    1612                 case MATROSKA_ID_CHAPTERS:
    1613                     if (demux_mkv_read_chapters (demuxer))
    1614                         res = 1;
    1615                     break;
    1616                 }
    1617         }
    1618 
    1619         stream_seek (s, saved_pos);
    1620     }
    1621     if (length > 0)
    1622         stream_seek (s, stream_tell (s) + length);
    1623     dprintf("[mkv] \\---- [ parsing seek head ] ---------\n");
    1624     return res;
    1625 }
    1626 
    1627 static void
    1628 display_tracks (mkv_demuxer_t *mkv_d)
    1629 {
    1630     int i, vid=0, aid=0, sid=0;
    1631 
    1632     for (i=0; i<mkv_d->num_tracks; i++)
    1633     {
    1634         char *type = "unknown", str[32];
    1635         *str = '\0';
    1636         switch (mkv_d->tracks[i]->type)
    1637         {
    1638         case MATROSKA_TRACK_VIDEO:
    1639             type = "video";
    1640             dprintf("ID_VIDEO_ID=%d\n", vid);
    1641             sprintf (str, "-vid %u", vid++);
    1642             break;
    1643         case MATROSKA_TRACK_AUDIO:
    1644             type = "audio";
    1645             dprintf("ID_AUDIO_ID=%d\n", aid);
    1646             dprintf("ID_AID_%d_LANG=%s\n", aid, mkv_d->tracks[i]->language);
    1647             sprintf (str, "-aid %u, -alang %.5s",aid++,mkv_d->tracks[i]->language);
    1648             break;
    1649         case MATROSKA_TRACK_SUBTITLE:
    1650             type = "subtitles";
    1651             dprintf("ID_SUBTITLE_ID=%d\n", sid);
    1652             dprintf("ID_SID_%d_LANG=%s\n", sid, mkv_d->tracks[i]->language);
    1653             sprintf (str, "-sid %u, -slang %.5s",sid++,mkv_d->tracks[i]->language);
    1654             break;
    1655         }
    1656         dprintf("[mkv] Track ID %u: %s (%s), %s\n",
    1657                 mkv_d->tracks[i]->tnum, type, mkv_d->tracks[i]->codec_id, str);
    1658     }
    1659 }
    1660 
    1661 static int
    1662 demux_mkv_open_video (demuxer_t *demuxer, mkv_track_t *track)
    1663 {
    1664     BITMAPINFOHEADERw *bih;
    1665     void *ImageDesc = NULL;
    1666     sh_video_t *sh_v;
    1667 
    1668     if (track->ms_compat)  /* MS compatibility mode */
    1669     {
    1670         BITMAPINFOHEADERw *src;
    1671 
    1672         if (track->private_data == NULL
    1673             || track->private_size < sizeof (BITMAPINFOHEADERw))
    1674             return 1;
    1675 
    1676         src = (BITMAPINFOHEADERw *) track->private_data;
    1677         bih = (BITMAPINFOHEADERw *) malloc (track->private_size);
    1678         memset (bih, 0, track->private_size);
    1679         bih->biSize = le2me_32 (src->biSize);
    1680         bih->biWidth = le2me_32 (src->biWidth);
    1681         bih->biHeight = le2me_32 (src->biHeight);
    1682         bih->biPlanes = le2me_16 (src->biPlanes);
    1683         bih->biBitCount = le2me_16 (src->biBitCount);
    1684         bih->biCompression = le2me_32 (src->biCompression);
    1685         bih->biSizeImage = le2me_32 (src->biSizeImage);
    1686         bih->biXPelsPerMeter = le2me_32 (src->biXPelsPerMeter);
    1687         bih->biYPelsPerMeter = le2me_32 (src->biYPelsPerMeter);
    1688         bih->biClrUsed = le2me_32 (src->biClrUsed);
    1689         bih->biClrImportant = le2me_32 (src->biClrImportant);
    1690         memcpy((char *) bih + sizeof (BITMAPINFOHEADERw),
    1691                (char *) src + sizeof (BITMAPINFOHEADERw),
    1692                track->private_size - sizeof (BITMAPINFOHEADERw));
    1693 
    1694         if (track->v_width == 0)
    1695             track->v_width = bih->biWidth;
    1696         if (track->v_height == 0)
    1697             track->v_height = bih->biHeight;
    1698     }
    1699     else
    1700     {
    1701         bih = (BITMAPINFOHEADERw*) malloc (sizeof (BITMAPINFOHEADERw));
    1702         memset (bih, 0, sizeof (BITMAPINFOHEADERw));
    1703         bih->biSize = sizeof (BITMAPINFOHEADERw);
    1704         bih->biWidth = track->v_width;
    1705         bih->biHeight = track->v_height;
    1706         bih->biBitCount = 24;
    1707         bih->biSizeImage = bih->biWidth * bih->biHeight * bih->biBitCount/8;
    1708 
    1709         if (track->private_size >= sizeof (real_video_props_t)
    1710             && (!strcmp (track->codec_id, MKV_V_REALV10)
    1711                 || !strcmp (track->codec_id, MKV_V_REALV20)
    1712                 || !strcmp (track->codec_id, MKV_V_REALV30)
    1713                 || !strcmp (track->codec_id, MKV_V_REALV40)))
    1714         {
    1715             unsigned char *dst, *src;
    1716             real_video_props_t *rvp;
    1717             uint32_t type2;
    1718 
    1719             rvp = (real_video_props_t *) track->private_data;
    1720             src = (unsigned char *) (rvp + 1);
    1721 
    1722             bih = (BITMAPINFOHEADERw *) realloc(bih,
    1723                                                 sizeof (BITMAPINFOHEADERw)+12);
    1724             bih->biSize = 48;
    1725             bih->biPlanes = 1;
    1726             type2 = be2me_32 (rvp->type2);
    1727             if (type2 == 0x10003000 || type2 == 0x10003001)
    1728                 bih->biCompression=mmioFOURCC('R','V','1','3');
    1729             else
    1730                 bih->biCompression=mmioFOURCC('R','V',track->codec_id[9],'0');
    1731             dst = (unsigned char *) (bih + 1);
    1732             ((unsigned int *) dst)[0] = be2me_32 (rvp->type1);
    1733             ((unsigned int *) dst)[1] = type2;
    1734 
    1735             if (bih->biCompression <= 0x30335652 && type2 >= 0x20200002)
    1736             {
    1737                 /* read secondary WxH for the cmsg24[] (see vd_realvid.c) */
    1738                 ((unsigned short *)(bih+1))[4] = 4 * (unsigned short) src[0];
    1739                 ((unsigned short *)(bih+1))[5] = 4 * (unsigned short) src[1];
    1740             }
    1741             else
    1742                 memset(&dst[8], 0, 4);
    1743             track->realmedia = 1;
    1744 
    1745 #ifdef USE_QTX_CODECS
    1746         }
    1747         else if (track->private_size >= sizeof (ImageDescription)
    1748                  && !strcmp(track->codec_id, MKV_V_QUICKTIME))
    1749         {
    1750             ImageDescriptionPtr idesc;
    1751 
    1752             idesc = (ImageDescriptionPtr) track->private_data;
    1753             idesc->idSize = be2me_32 (idesc->idSize);
    1754             idesc->cType = be2me_32 (idesc->cType);
    1755             idesc->version = be2me_16 (idesc->version);
    1756             idesc->revisionLevel = be2me_16 (idesc->revisionLevel);
    1757             idesc->vendor = be2me_32 (idesc->vendor);
    1758             idesc->temporalQuality = be2me_32 (idesc->temporalQuality);
    1759             idesc->spatialQuality = be2me_32 (idesc->spatialQuality);
    1760             idesc->width = be2me_16 (idesc->width);
    1761             idesc->height = be2me_16 (idesc->height);
    1762             idesc->hRes = be2me_32 (idesc->hRes);
    1763             idesc->vRes = be2me_32 (idesc->vRes);
    1764             idesc->dataSize = be2me_32 (idesc->dataSize);
    1765             idesc->frameCount = be2me_16 (idesc->frameCount);
    1766             idesc->depth = be2me_16 (idesc->depth);
    1767             idesc->clutID = be2me_16 (idesc->clutID);
    1768             bih->biPlanes = 1;
    1769             bih->biCompression = idesc->cType;
    1770             ImageDesc = idesc;
    1771 #endif /* USE_QTX_CODECS */
    1772 
    1773         }
    1774         else if (!strcmp(track->codec_id, MKV_V_MPEG1))
    1775         {
    1776             bih->biCompression = mmioFOURCC('m', 'p', 'g', '1');
    1777             track->reorder_timecodes = 1;
    1778         }
    1779         else if (!strcmp(track->codec_id, MKV_V_MPEG2))
    1780         {
    1781             bih->biCompression = mmioFOURCC('m', 'p', 'g', '2');
    1782             track->reorder_timecodes = 1;
    1783         }
    1784         else if (!strcmp(track->codec_id, MKV_V_MPEG4_SP) ||
    1785                  !strcmp(track->codec_id, MKV_V_MPEG4_ASP) ||
    1786                  !strcmp(track->codec_id, MKV_V_MPEG4_AP))
    1787         {
    1788             bih->biCompression = mmioFOURCC('m', 'p', '4', 'v');
    1789             if (track->private_data && (track->private_size > 0))
    1790             {
    1791                 bih->biSize += track->private_size;
    1792                 bih = (BITMAPINFOHEADERw *) realloc (bih, bih->biSize);
    1793                 memcpy (bih + 1, track->private_data, track->private_size);
    1794             }
    1795             track->reorder_timecodes = !correct_pts;
    1796         }
    1797         else if (!strcmp(track->codec_id, MKV_V_MPEG4_AVC))
    1798         {
    1799             bih->biCompression = mmioFOURCC('a', 'v', 'c', '1');
    1800             if (track->private_data && (track->private_size > 0))
    1801             {
    1802                 bih->biSize += track->private_size;
    1803                 bih = (BITMAPINFOHEADERw *) realloc (bih, bih->biSize);
    1804                 memcpy (bih + 1, track->private_data, track->private_size);
    1805             }
    1806             track->reorder_timecodes = 1;
    1807         }
    1808         else
    1809         {
    1810             dprintf ("[mkv] Unknown/unsupported CodecID "
    1811                      "(%s) or missing/bad CodecPrivate data (track %u).\n",
    1812                      track->codec_id, track->tnum);
    1813             free(bih);
    1814             return 1;
    1815         }
    1816     }
    1817 
    1818     sh_v = new_sh_video (demuxer, track->tnum);
    1819     sh_v->bih = bih;
    1820     sh_v->format = sh_v->bih->biCompression;
    1821     if (track->v_frate == 0.0)
    1822         track->v_frate = 25.0;
    1823     sh_v->fps = track->v_frate;
    1824     sh_v->frametime = 1 / track->v_frate;
    1825     sh_v->aspect = 0;
    1826     if (!track->realmedia)
    1827     {
    1828         sh_v->disp_w = track->v_width;
    1829         sh_v->disp_h = track->v_height;
    1830         if (track->v_dheight)
    1831             sh_v->aspect = (float)track->v_dwidth / (float)track->v_dheight;
    1832     }
    1833     else
    1834     {
    1835         // vd_realvid.c will set aspect to disp_w/disp_h and rederive
    1836         // disp_w and disp_h from the RealVideo stream contents returned
    1837         // by the Real DLLs. If DisplayWidth/DisplayHeight was not set in
    1838         // the Matroska file then it has already been set to PixelWidth/Height
    1839         // by check_track_information.
    1840         sh_v->disp_w = track->v_dwidth;
    1841         sh_v->disp_h = track->v_dheight;
    1842     }
    1843     sh_v->ImageDesc = ImageDesc;
    1844     dprintf ("[mkv] Aspect: %f\n", sh_v->aspect);
    1845 
    1846     sh_v->ds = demuxer->video;
    1847     return 0;
    1848 }
    1849 
    1850 static int
    1851 demux_mkv_open_audio (demuxer_t *demuxer, mkv_track_t *track)
    1852 {
    1853     mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
    1854     sh_audio_t *sh_a = new_sh_audio(demuxer, track->tnum);
    1855     if(!sh_a) return 1;
    1856     mkv_d->audio_tracks[mkv_d->last_aid] = track->tnum;
    1857     demux_packet_t *dp;
    1858 
    1859     sh_a->ds = demuxer->audio;
    1860     sh_a->wf = (WAVEFORMATEX *) malloc (sizeof (WAVEFORMATEX));
    1861     if (track->ms_compat && (track->private_size >= sizeof(WAVEFORMATEX)))
    1862     {
    1863         WAVEFORMATEX *wf = (WAVEFORMATEX *)track->private_data;
    1864         sh_a->wf = (WAVEFORMATEX *) realloc(sh_a->wf, track->private_size);
    1865         sh_a->wf->wFormatTag = le2me_16 (wf->wFormatTag);
    1866         sh_a->wf->nChannels = le2me_16 (wf->nChannels);
    1867         sh_a->wf->nSamplesPerSec = le2me_32 (wf->nSamplesPerSec);
    1868         sh_a->wf->nAvgBytesPerSec = le2me_32 (wf->nAvgBytesPerSec);
    1869         sh_a->wf->nBlockAlign = le2me_16 (wf->nBlockAlign);
    1870         sh_a->wf->wBitsPerSample = le2me_16 (wf->wBitsPerSample);
    1871         sh_a->wf->cbSize = track->private_size - sizeof(WAVEFORMATEX);
    1872         memcpy(sh_a->wf + 1, wf + 1, track->private_size - sizeof(WAVEFORMATEX));
    1873         if (track->a_sfreq == 0.0)
    1874             track->a_sfreq = sh_a->wf->nSamplesPerSec;
    1875         if (track->a_channels == 0)
    1876             track->a_channels = sh_a->wf->nChannels;
    1877         if (track->a_bps == 0)
    1878             track->a_bps = sh_a->wf->wBitsPerSample;
    1879         track->a_formattag = sh_a->wf->wFormatTag;
    1880     }
    1881     else
    1882     {
    1883         memset(sh_a->wf, 0, sizeof (WAVEFORMATEX));
    1884         if (!strcmp(track->codec_id, MKV_A_MP3) ||
    1885             !strcmp(track->codec_id, MKV_A_MP2))
    1886             track->a_formattag = 0x0055;
    1887         else if (!strncmp(track->codec_id, MKV_A_AC3, strlen(MKV_A_AC3)))
    1888             track->a_formattag = 0x2000;
    1889         else if (!strcmp(track->codec_id, MKV_A_DTS))
    1890             track->a_formattag = 0x2001;
    1891         else if (!strcmp(track->codec_id, MKV_A_PCM) ||
    1892                  !strcmp(track->codec_id, MKV_A_PCM_BE))
    1893             track->a_formattag = 0x0001;
    1894         else if (!strcmp(track->codec_id, MKV_A_AAC_2MAIN) ||
    1895                  !strncmp(track->codec_id, MKV_A_AAC_2LC,
    1896                           strlen(MKV_A_AAC_2LC)) ||
    1897                  !strcmp(track->codec_id, MKV_A_AAC_2SSR) ||
    1898                  !strcmp(track->codec_id, MKV_A_AAC_4MAIN) ||
    1899                  !strncmp(track->codec_id, MKV_A_AAC_4LC,
    1900                           strlen(MKV_A_AAC_4LC)) ||
    1901                  !strcmp(track->codec_id, MKV_A_AAC_4SSR) ||
    1902                  !strcmp(track->codec_id, MKV_A_AAC_4LTP) ||
    1903                  !strcmp(track->codec_id, MKV_A_AAC))
    1904             track->a_formattag = mmioFOURCC('M', 'P', '4', 'A');
    1905         else if (!strcmp(track->codec_id, MKV_A_VORBIS))
    1906         {
    1907             if (track->private_data == NULL)
    1908                 return 1;
    1909             track->a_formattag = mmioFOURCC('v', 'r', 'b', 's');
    1910         }
    1911         else if (!strcmp(track->codec_id, MKV_A_QDMC))
    1912             track->a_formattag = mmioFOURCC('Q', 'D', 'M', 'C');
    1913         else if (!strcmp(track->codec_id, MKV_A_QDMC2))
    1914             track->a_formattag = mmioFOURCC('Q', 'D', 'M', '2');
    1915         else if (!strcmp(track->codec_id, MKV_A_FLAC))
    1916         {
    1917             if (track->private_data == NULL || track->private_size == 0)
    1918             {
    1919                 dprintf ( "[mkv] FLAC track does not "
    1920                          "contain valid headers.\n");
    1921                 return 1;
    1922             }
    1923             track->a_formattag = mmioFOURCC ('f', 'L', 'a', 'C');
    1924         }
    1925         else if (track->private_size >= sizeof (real_audio_v4_props_t))
    1926         {
    1927             if (!strcmp(track->codec_id, MKV_A_REAL28))
    1928                 track->a_formattag = mmioFOURCC('2', '8', '_', '8');
    1929             else if (!strcmp(track->codec_id, MKV_A_REALATRC))
    1930                 track->a_formattag = mmioFOURCC('a', 't', 'r', 'c');
    1931             else if (!strcmp(track->codec_id, MKV_A_REALCOOK))
    1932                 track->a_formattag = mmioFOURCC('c', 'o', 'o', 'k');
    1933             else if (!strcmp(track->codec_id, MKV_A_REALDNET))
    1934                 track->a_formattag = mmioFOURCC('d', 'n', 'e', 't');
    1935             else if (!strcmp(track->codec_id, MKV_A_REALSIPR))
    1936                 track->a_formattag = mmioFOURCC('s', 'i', 'p', 'r');
    1937         }
    1938         else
    1939         {
    1940             dprintf ( "[mkv] Unknown/unsupported audio "
    1941                      "codec ID '%s' for track %u or missing/faulty private "
    1942                      "codec data.\n", track->codec_id, track->tnum);
    1943             free_sh_audio (sh_a);
    1944             return 1;
    1945         }
    1946     }
    1947 
    1948     sh_a->format = track->a_formattag;
    1949     sh_a->wf->wFormatTag = track->a_formattag;
    1950     sh_a->channels = track->a_channels;
    1951     sh_a->wf->nChannels = track->a_channels;
    1952     sh_a->samplerate = (uint32_t) track->a_sfreq;
    1953     sh_a->wf->nSamplesPerSec = (uint32_t) track->a_sfreq;
    1954     if (track->a_bps == 0)
    1955     {
    1956         sh_a->samplesize = 2;
    1957         sh_a->wf->wBitsPerSample = 16;
    1958     }
    1959     else
    1960     {
    1961         sh_a->samplesize = track->a_bps / 8;
    1962         sh_a->wf->wBitsPerSample = track->a_bps;
    1963     }
    1964     if (track->a_formattag == 0x0055)  /* MP3 || MP2 */
    1965     {
    1966         sh_a->wf->nAvgBytesPerSec = 16000;
    1967         sh_a->wf->nBlockAlign = 1152;
    1968     }
    1969     else if ((track->a_formattag == 0x2000) || /* AC3 */
    1970              (track->a_formattag == 0x2001)) /* DTS */
    1971     {
    1972         sh_a->wf->nAvgBytesPerSec = 16000;
    1973         sh_a->wf->nBlockAlign = 1536;
    1974     }
    1975     else if (track->a_formattag == 0x0001)  /* PCM || PCM_BE */
    1976     {
    1977         sh_a->wf->nAvgBytesPerSec = sh_a->channels * sh_a->samplerate*2;
    1978         sh_a->wf->nBlockAlign = sh_a->wf->nAvgBytesPerSec;
    1979         if (!strcmp(track->codec_id, MKV_A_PCM_BE))
    1980             sh_a->format = mmioFOURCC('t', 'w', 'o', 's');
    1981     }
    1982     else if (!strcmp(track->codec_id, MKV_A_QDMC) ||
    1983              !strcmp(track->codec_id, MKV_A_QDMC2))
    1984     {
    1985         sh_a->wf->nAvgBytesPerSec = 16000;
    1986         sh_a->wf->nBlockAlign = 1486;
    1987         track->fix_i_bps = 1;
    1988         track->qt_last_a_pts = 0.0;
    1989         if (track->private_data != NULL)
    1990         {
    1991             sh_a->codecdata=(unsigned char *)malloc(track->private_size);
    1992             memcpy (sh_a->codecdata, track->private_data,
    1993                     track->private_size);
    1994             sh_a->codecdata_len = track->private_size;
    1995         }
    1996     }
    1997     else if (track->a_formattag == mmioFOURCC('M', 'P', '4', 'A'))
    1998     {
    1999         int profile, srate_idx;
    2000 
    2001         sh_a->wf->nAvgBytesPerSec = 16000;
    2002         sh_a->wf->nBlockAlign = 1024;
    2003 
    2004         if (!strcmp (track->codec_id, MKV_A_AAC) &&
    2005             (NULL != track->private_data))
    2006         {
    2007             sh_a->codecdata=(unsigned char *)malloc(track->private_size);
    2008             memcpy (sh_a->codecdata, track->private_data,
    2009                     track->private_size);
    2010             sh_a->codecdata_len = track->private_size;
    2011             return 0;
    2012         }
    2013 
    2014         /* Recreate the 'private data' */
    2015         /* which faad2 uses in its initialization */
    2016         srate_idx = aac_get_sample_rate_index (sh_a->samplerate);
    2017         if (!strncmp (&track->codec_id[12], "MAIN", 4))
    2018             profile = 0;
    2019         else if (!strncmp (&track->codec_id[12], "LC", 2))
    2020             profile = 1;
    2021         else if (!strncmp (&track->codec_id[12], "SSR", 3))
    2022             profile = 2;
    2023         else
    2024             profile = 3;
    2025         sh_a->codecdata = (unsigned char *) malloc (5);
    2026         sh_a->codecdata[0] = ((profile+1) << 3) | ((srate_idx&0xE) >> 1);
    2027         sh_a->codecdata[1] = ((srate_idx&0x1)<<7)|(track->a_channels<<3);
    2028 
    2029         if (strstr(track->codec_id, "SBR") != NULL)
    2030         {
    2031             /* HE-AAC (aka SBR AAC) */
    2032             sh_a->codecdata_len = 5;
    2033 
    2034             sh_a->samplerate *= 2;
    2035             sh_a->wf->nSamplesPerSec *= 2;
    2036             srate_idx = aac_get_sample_rate_index(sh_a->samplerate);
    2037             sh_a->codecdata[2] = AAC_SYNC_EXTENSION_TYPE >> 3;
    2038             sh_a->codecdata[3] = ((AAC_SYNC_EXTENSION_TYPE&0x07)<<5) | 5;
    2039             sh_a->codecdata[4] = (1 << 7) | (srate_idx << 3);
    2040             track->default_duration = 1024.0 / (sh_a->samplerate / 2);
    2041         }
    2042         else
    2043         {
    2044             sh_a->codecdata_len = 2;
    2045             track->default_duration = 1024.0 / (float)sh_a->samplerate;
    2046         }
    2047     }
    2048     else if (track->a_formattag == mmioFOURCC('v', 'r', 'b', 's'))  /* VORBIS */
    2049     {
    2050         sh_a->wf->cbSize = track->private_size;
    2051         sh_a->wf = (WAVEFORMATEX*)realloc(sh_a->wf, sizeof(WAVEFORMATEX) + sh_a->wf->cbSize);
    2052         memcpy((unsigned char *) (sh_a->wf+1), track->private_data, sh_a->wf->cbSize);
    2053     }
    2054     else if (track->private_size >= sizeof(real_audio_v4_props_t)
    2055              && !strncmp (track->codec_id, MKV_A_REALATRC, 7))
    2056     {
    2057         /* Common initialization for all RealAudio codecs */
    2058         real_audio_v4_props_t *ra4p;
    2059         real_audio_v5_props_t *ra5p;
    2060         unsigned char *src;
    2061         int codecdata_length, version;
    2062 
    2063         ra4p = (real_audio_v4_props_t *) track->private_data;
    2064         ra5p = (real_audio_v5_props_t *) track->private_data;
    2065 
    2066         sh_a->wf->nAvgBytesPerSec = 0;  /* FIXME !? */
    2067         sh_a->wf->nBlockAlign = be2me_16 (ra4p->frame_size);
    2068 
    2069         version = be2me_16 (ra4p->version1);
    2070 
    2071         if (version == 4)
    2072         {
    2073             src = (unsigned char *) (ra4p + 1);
    2074             src += src[0] + 1;
    2075             src += src[0] + 1;
    2076             track->sub_packet_size = be2me_16 (ra4p->sub_packet_size);
    2077             track->sub_packet_h = be2me_16 (ra4p->sub_packet_h);
    2078             track->coded_framesize = be2me_32 (ra4p->coded_frame_size);
    2079             track->audiopk_size = be2me_16 (ra4p->frame_size);
    2080         }
    2081         else
    2082         {
    2083             src = (unsigned char *) (ra5p + 1);
    2084             track->sub_packet_size = be2me_16 (ra5p->sub_packet_size);
    2085             track->sub_packet_h = be2me_16 (ra5p->sub_packet_h);
    2086             track->coded_framesize = be2me_32 (ra5p->coded_frame_size);
    2087             track->audiopk_size = be2me_16 (ra5p->frame_size);
    2088         }
    2089 
    2090         src += 3;
    2091         if (version == 5)
    2092             src++;
    2093         codecdata_length = be2me_32 (*(uint32_t *)src);
    2094         src += 4;
    2095         sh_a->wf->cbSize = codecdata_length;
    2096         sh_a->wf = (WAVEFORMATEX *) realloc (sh_a->wf,
    2097                                              sizeof (WAVEFORMATEX) +
    2098                                              sh_a->wf->cbSize);
    2099         memcpy(((char *)(sh_a->wf + 1)), src, codecdata_length);
    2100 
    2101         switch (track->a_formattag) {
     2067          track->a_formattag = mmioFOURCC ('f', 'L', 'a', 'C');
     2068        }
     2069      else if (track->private_size >= sizeof (real_audio_v4_props_t))
     2070        {
     2071          if (!strcmp(track->codec_id, MKV_A_REAL28))
     2072            track->a_formattag = mmioFOURCC('2', '8', '_', '8');
     2073          else if (!strcmp(track->codec_id, MKV_A_REALATRC))
     2074            track->a_formattag = mmioFOURCC('a', 't', 'r', 'c');
     2075          else if (!strcmp(track->codec_id, MKV_A_REALCOOK))
     2076            track->a_formattag = mmioFOURCC('c', 'o', 'o', 'k');
     2077          else if (!strcmp(track->codec_id, MKV_A_REALDNET))
     2078            track->a_formattag = mmioFOURCC('d', 'n', 'e', 't');
     2079          else if (!strcmp(track->codec_id, MKV_A_REALSIPR))
     2080            track->a_formattag = mmioFOURCC('s', 'i', 'p', 'r');
     2081        }
     2082      else
     2083        {
     2084          dprintf( MSGTR_MPDEMUX_MKV_UnknownAudioCodec,
     2085                  track->codec_id, track->tnum);
     2086          free_sh_audio(demuxer, track->tnum);
     2087          return 1;
     2088        }
     2089    }
     2090
     2091  sh_a->format = track->a_formattag;
     2092  sh_a->wf->wFormatTag = track->a_formattag;
     2093  sh_a->channels = track->a_channels;
     2094  sh_a->wf->nChannels = track->a_channels;
     2095  sh_a->samplerate = (uint32_t) track->a_sfreq;
     2096  sh_a->wf->nSamplesPerSec = (uint32_t) track->a_sfreq;
     2097  if (track->a_bps == 0)
     2098    {
     2099      sh_a->samplesize = 2;
     2100      sh_a->wf->wBitsPerSample = 16;
     2101    }
     2102  else
     2103    {
     2104      sh_a->samplesize = track->a_bps / 8;
     2105      sh_a->wf->wBitsPerSample = track->a_bps;
     2106    }
     2107  if (track->a_formattag == 0x0055)  /* MP3 || MP2 */
     2108    {
     2109      sh_a->wf->nAvgBytesPerSec = 16000;
     2110      sh_a->wf->nBlockAlign = 1152;
     2111    }
     2112  else if ((track->a_formattag == 0x2000) || /* AC3 */
     2113           (track->a_formattag == 0x2001)) /* DTS */
     2114    {
     2115      sh_a->wf->nAvgBytesPerSec = 16000;
     2116      sh_a->wf->nBlockAlign = 1536;
     2117    }
     2118  else if (track->a_formattag == 0x0001)  /* PCM || PCM_BE */
     2119    {
     2120      sh_a->wf->nAvgBytesPerSec = sh_a->channels * sh_a->samplerate*2;
     2121      sh_a->wf->nBlockAlign = sh_a->wf->nAvgBytesPerSec;
     2122      if (!strcmp(track->codec_id, MKV_A_PCM_BE))
     2123        sh_a->format = mmioFOURCC('t', 'w', 'o', 's');
     2124    }
     2125  else if (!strcmp(track->codec_id, MKV_A_QDMC) ||
     2126           !strcmp(track->codec_id, MKV_A_QDMC2))
     2127    {
     2128      sh_a->wf->nAvgBytesPerSec = 16000;
     2129      sh_a->wf->nBlockAlign = 1486;
     2130      track->fix_i_bps = 1;
     2131      track->qt_last_a_pts = 0.0;
     2132      if (track->private_data != NULL)
     2133        {
     2134          sh_a->codecdata=malloc(track->private_size);
     2135          memcpy (sh_a->codecdata, track->private_data,
     2136                  track->private_size);
     2137          sh_a->codecdata_len = track->private_size;
     2138        }
     2139    }
     2140  else if (track->a_formattag == mmioFOURCC('M', 'P', '4', 'A'))
     2141    {
     2142      int profile, srate_idx;
     2143
     2144      sh_a->wf->nAvgBytesPerSec = 16000;
     2145      sh_a->wf->nBlockAlign = 1024;
     2146
     2147      if (!strcmp (track->codec_id, MKV_A_AAC) &&
     2148          (NULL != track->private_data))
     2149        {
     2150          sh_a->codecdata=malloc(track->private_size);
     2151          memcpy (sh_a->codecdata, track->private_data,
     2152                  track->private_size);
     2153          sh_a->codecdata_len = track->private_size;
     2154          return 0;
     2155        }
     2156
     2157      /* Recreate the 'private data' */
     2158      /* which faad2 uses in its initialization */
     2159      srate_idx = aac_get_sample_rate_index (sh_a->samplerate);
     2160      if (!strncmp (&track->codec_id[12], "MAIN", 4))
     2161        profile = 0;
     2162      else if (!strncmp (&track->codec_id[12], "LC", 2))
     2163        profile = 1;
     2164      else if (!strncmp (&track->codec_id[12], "SSR", 3))
     2165        profile = 2;
     2166      else
     2167        profile = 3;
     2168      sh_a->codecdata = malloc (5);
     2169      sh_a->codecdata[0] = ((profile+1) << 3) | ((srate_idx&0xE) >> 1);
     2170      sh_a->codecdata[1] = ((srate_idx&0x1)<<7)|(track->a_channels<<3);
     2171
     2172      if (strstr(track->codec_id, "SBR") != NULL)
     2173        {
     2174          /* HE-AAC (aka SBR AAC) */
     2175          sh_a->codecdata_len = 5;
     2176
     2177          sh_a->samplerate *= 2;
     2178          sh_a->wf->nSamplesPerSec *= 2;
     2179          srate_idx = aac_get_sample_rate_index(sh_a->samplerate);
     2180          sh_a->codecdata[2] = AAC_SYNC_EXTENSION_TYPE >> 3;
     2181          sh_a->codecdata[3] = ((AAC_SYNC_EXTENSION_TYPE&0x07)<<5) | 5;
     2182          sh_a->codecdata[4] = (1 << 7) | (srate_idx << 3);
     2183          track->default_duration = 1024.0 / (sh_a->samplerate / 2);
     2184        }
     2185      else
     2186        {
     2187          sh_a->codecdata_len = 2;
     2188          track->default_duration = 1024.0 / (float)sh_a->samplerate;
     2189        }
     2190    }
     2191  else if (track->a_formattag == mmioFOURCC('v', 'r', 'b', 's'))  /* VORBIS */
     2192    {
     2193      sh_a->wf->cbSize = track->private_size;
     2194      sh_a->wf = realloc(sh_a->wf, sizeof(WAVEFORMATEX) + sh_a->wf->cbSize);
     2195      memcpy((unsigned char *) (sh_a->wf+1), track->private_data, sh_a->wf->cbSize);
     2196    }
     2197  else if (track->private_size >= sizeof(real_audio_v4_props_t)
     2198           && !strncmp (track->codec_id, MKV_A_REALATRC, 7))
     2199    {
     2200      /* Common initialization for all RealAudio codecs */
     2201      real_audio_v4_props_t *ra4p;
     2202      real_audio_v5_props_t *ra5p;
     2203      unsigned char *src;
     2204      int codecdata_length, version;
     2205
     2206      ra4p = (real_audio_v4_props_t *) track->private_data;
     2207      ra5p = (real_audio_v5_props_t *) track->private_data;
     2208
     2209      sh_a->wf->nAvgBytesPerSec = 0;  /* FIXME !? */
     2210      sh_a->wf->nBlockAlign = be2me_16 (ra4p->frame_size);
     2211
     2212      version = be2me_16 (ra4p->version1);
     2213
     2214      if (version == 4)
     2215        {
     2216          src = (unsigned char *) (ra4p + 1);
     2217          src += src[0] + 1;
     2218          src += src[0] + 1;
     2219          track->sub_packet_size = be2me_16 (ra4p->sub_packet_size);
     2220          track->sub_packet_h = be2me_16 (ra4p->sub_packet_h);
     2221          track->coded_framesize = be2me_32 (ra4p->coded_frame_size);
     2222          track->audiopk_size = be2me_16 (ra4p->frame_size);
     2223        }
     2224      else
     2225        {
     2226        src = (unsigned char *) (ra5p + 1);
     2227        track->sub_packet_size = be2me_16 (ra5p->sub_packet_size);
     2228        track->sub_packet_h = be2me_16 (ra5p->sub_packet_h);
     2229        track->coded_framesize = be2me_32 (ra5p->coded_frame_size);
     2230        track->audiopk_size = be2me_16 (ra5p->frame_size);
     2231        }
     2232
     2233      src += 3;
     2234      if (version == 5)
     2235        src++;
     2236      codecdata_length = be2me_32 (*(uint32_t *)src);
     2237      src += 4;
     2238      sh_a->wf->cbSize = codecdata_length;
     2239      sh_a->wf = realloc (sh_a->wf,
     2240                          sizeof (WAVEFORMATEX) +
     2241                          sh_a->wf->cbSize);
     2242      memcpy(((char *)(sh_a->wf + 1)), src, codecdata_length);
     2243
     2244      switch (track->a_formattag) {
    21022245        case mmioFOURCC('a', 't', 'r', 'c'):
    2103             sh_a->wf->nAvgBytesPerSec = atrc_fl2bps[be2me_16 (ra4p->flavor)];
    2104             sh_a->wf->nBlockAlign = track->sub_packet_size;
    2105             track->audio_buf = malloc(track->sub_packet_h * track->audiopk_size);
    2106             track->audio_timestamp = malloc(track->sub_packet_h * sizeof(float));
    2107             break;
     2246          sh_a->wf->nAvgBytesPerSec = atrc_fl2bps[be2me_16 (ra4p->flavor)];
     2247          sh_a->wf->nBlockAlign = track->sub_packet_size;
     2248          track->audio_buf = malloc(track->sub_packet_h * track->audiopk_size);
     2249          track->audio_timestamp = malloc(track->sub_packet_h * sizeof(float));
     2250          break;
    21082251        case mmioFOURCC('c', 'o', 'o', 'k'):
    2109             sh_a->wf->nAvgBytesPerSec = cook_fl2bps[be2me_16 (ra4p->flavor)];
    2110             sh_a->wf->nBlockAlign = track->sub_packet_size;
    2111             track->audio_buf = malloc(track->sub_packet_h * track->audiopk_size);
    2112             track->audio_timestamp = malloc(track->sub_packet_h * sizeof(float));
    2113             break;
     2252          sh_a->wf->nAvgBytesPerSec = cook_fl2bps[be2me_16 (ra4p->flavor)];
     2253          sh_a->wf->nBlockAlign = track->sub_packet_size;
     2254          track->audio_buf = malloc(track->sub_packet_h * track->audiopk_size);
     2255          track->audio_timestamp = malloc(track->sub_packet_h * sizeof(float));
     2256          break;
    21142257        case mmioFOURCC('s', 'i', 'p', 'r'):
    2115             sh_a->wf->nAvgBytesPerSec = sipr_fl2bps[be2me_16 (ra4p->flavor)];
    2116             sh_a->wf->nBlockAlign = track->coded_framesize;
    2117             track->audio_buf = malloc(track->sub_packet_h * track->audiopk_size);
    2118             track->audio_timestamp = malloc(track->sub_packet_h * sizeof(float));
    2119             break;
     2258          sh_a->wf->nAvgBytesPerSec = sipr_fl2bps[be2me_16 (ra4p->flavor)];
     2259          sh_a->wf->nBlockAlign = track->coded_framesize;
     2260          track->audio_buf = malloc(track->sub_packet_h * track->audiopk_size);
     2261          track->audio_timestamp = malloc(track->sub_packet_h * sizeof(float));
     2262          break;
    21202263        case mmioFOURCC('2', '8', '_', '8'):
    2121             sh_a->wf->nAvgBytesPerSec = 3600;
    2122             sh_a->wf->nBlockAlign = track->coded_framesize;
    2123             track->audio_buf = malloc(track->sub_packet_h * track->audiopk_size);
    2124             track->audio_timestamp = malloc(track->sub_packet_h * sizeof(float));
    2125             break;
    2126         }
    2127 
    2128         track->realmedia = 1;
    2129     }
    2130     else if (!strcmp(track->codec_id, MKV_A_FLAC) ||
    2131              (track->a_formattag == 0xf1ac))
    2132     {
    2133         unsigned char *ptr;
    2134         int size;
    2135         free(sh_a->wf);
    2136         sh_a->wf = NULL;
    2137 
    2138         if (track->a_formattag == mmioFOURCC('f', 'L', 'a', 'C'))
    2139         {
    2140             ptr = (unsigned char *)track->private_data;
    2141             size = track->private_size;
    2142         }
    2143         else
    2144         {
    2145             sh_a->format = mmioFOURCC('f', 'L', 'a', 'C');
    2146             ptr = (unsigned char *) track->private_data
    2147                 + sizeof (WAVEFORMATEX);
    2148             size = track->private_size - sizeof (WAVEFORMATEX);
    2149         }
    2150         if (size < 4 || ptr[0] != 'f' || ptr[1] != 'L' ||
    2151             ptr[2] != 'a' || ptr[3] != 'C')
    2152         {
    2153             dp = new_demux_packet (4);
    2154             memcpy (dp->buffer, "fLaC", 4);
    2155         }
    2156         else
    2157         {
    2158             dp = new_demux_packet (size);
    2159             memcpy (dp->buffer, ptr, size);
    2160         }
    2161         dp->pts = 0;
    2162         dp->flags = 0;
    2163         ds_add_packet (demuxer->audio, dp);
    2164     }
    2165     else if (!track->ms_compat || (track->private_size < sizeof(WAVEFORMATEX)))
    2166     {
    2167         free_sh_audio (sh_a);
    2168         return 1;
    2169     }
    2170 
    2171     return 0;
     2264          sh_a->wf->nAvgBytesPerSec = 3600;
     2265          sh_a->wf->nBlockAlign = track->coded_framesize;
     2266          track->audio_buf = malloc(track->sub_packet_h * track->audiopk_size);
     2267          track->audio_timestamp = malloc(track->sub_packet_h * sizeof(float));
     2268          break;
     2269      }
     2270
     2271      track->realmedia = 1;
     2272    }
     2273  else if (!strcmp(track->codec_id, MKV_A_FLAC) ||
     2274           (track->a_formattag == 0xf1ac))
     2275    {
     2276      unsigned char *ptr;
     2277      int size;
     2278      free(sh_a->wf);
     2279      sh_a->wf = NULL;
     2280
     2281      if (track->a_formattag == mmioFOURCC('f', 'L', 'a', 'C'))
     2282        {
     2283          ptr = (unsigned char *)track->private_data;
     2284          size = track->private_size;
     2285        }
     2286      else
     2287        {
     2288          sh_a->format = mmioFOURCC('f', 'L', 'a', 'C');
     2289          ptr = (unsigned char *) track->private_data
     2290            + sizeof (WAVEFORMATEX);
     2291          size = track->private_size - sizeof (WAVEFORMATEX);
     2292        }
     2293      if (size < 4 || ptr[0] != 'f' || ptr[1] != 'L' ||
     2294          ptr[2] != 'a' || ptr[3] != 'C')
     2295        {
     2296          dp = new_demux_packet (4);
     2297          memcpy (dp->buffer, "fLaC", 4);
     2298        }
     2299      else
     2300        {
     2301          dp = new_demux_packet (size);
     2302          memcpy (dp->buffer, ptr, size);
     2303        }
     2304      dp->pts = 0;
     2305      dp->flags = 0;
     2306      ds_add_packet (demuxer->audio, dp);
     2307    }
     2308  else if (!track->ms_compat || (track->private_size < sizeof(WAVEFORMATEX)))
     2309    {
     2310      free_sh_audio(demuxer, track->tnum);
     2311      return 1;
     2312    }
     2313
     2314  return 0;
    21722315}
    21732316
    21742317/** \brief Parse the private data for VobSub subtitle tracks.
    21752318
    2176 This function tries to parse the private data for all VobSub tracks.
    2177 The private data contains the normal text from the original .idx file.
    2178 Things like the palette, subtitle dimensions and custom colors are
    2179 stored here.
    2180 
    2181 \param demuxer The generic demuxer.
     2319  This function tries to parse the private data for all VobSub tracks.
     2320  The private data contains the normal text from the original .idx file.
     2321  Things like the palette, subtitle dimensions and custom colors are
     2322  stored here.
     2323
     2324  \param demuxer The generic demuxer.
    21822325*/
    21832326static void
    21842327demux_mkv_parse_vobsub_data (demuxer_t *demuxer)
    21852328{
    2186     mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
    2187     mkv_track_t *track;
    2188     int i, m, size;
    2189     uint8_t *buffer;
    2190 
    2191     for (i = 0; i < mkv_d->num_tracks; i++)
    2192     {
    2193         track = mkv_d->tracks[i];
    2194         if ((track->type != MATROSKA_TRACK_SUBTITLE) ||
    2195             (track->subtitle_type != MATROSKA_SUBTYPE_VOBSUB))
    2196             continue;
    2197 
    2198         size = track->private_size;
    2199         m = demux_mkv_decode (track,track->private_data,&buffer,&size,2);
    2200         if (buffer && m)
    2201         {
    2202             free (track->private_data);
    2203             track->private_data = buffer;
    2204             track->private_size = size;
    2205         }
    2206         if (!demux_mkv_parse_idx (track))
    2207         {
    2208             free (track->private_data);
    2209             track->private_data = NULL;
    2210             track->private_size = 0;
    2211         }
    2212     }
    2213 }
     2329  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
     2330  mkv_track_t *track;
     2331  int i, m, size;
     2332  uint8_t *buffer;
     2333
     2334  for (i = 0; i < mkv_d->num_tracks; i++)
     2335    {
     2336      track = mkv_d->tracks[i];
     2337      if ((track->type != MATROSKA_TRACK_SUBTITLE) ||
     2338          (track->subtitle_type != MATROSKA_SUBTYPE_VOBSUB))
     2339        continue;
     2340
     2341      size = track->private_size;
     2342      m = demux_mkv_decode (track,track->private_data,&buffer,&size,2);
     2343      if (buffer && m)
     2344        {
     2345          free (track->private_data);
     2346          track->private_data = buffer;
     2347          track->private_size = size;
     2348        }
     2349      if (!demux_mkv_parse_idx (track))
     2350        {
     2351          free (track->private_data);
     2352          track->private_data = NULL;
     2353          track->private_size = 0;
     2354        }
     2355    }
     2356}
     2357
     2358/** \brief Parse the private data for SSA/ASS subtitle tracks.
     2359
     2360  This function tries to parse the private data for all SSA/ASS tracks.
     2361  The private data contains the normal text from the original script,
     2362  from the start to the beginning of 'Events' section, including '[Events]' line.
     2363
     2364  \param demuxer The generic demuxer.
     2365*/
     2366#ifdef USE_ASS
     2367static void
     2368demux_mkv_parse_ass_data (demuxer_t *demuxer)
     2369{
     2370  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
     2371  mkv_track_t *track;
     2372  int i, m, size;
     2373  uint8_t *buffer;
     2374
     2375  for (i = 0; i < mkv_d->num_tracks; i++)
     2376    {
     2377      track = mkv_d->tracks[i];
     2378      if (track->type != MATROSKA_TRACK_SUBTITLE)
     2379        continue;
     2380
     2381      track->sh_sub.type = 'a';
     2382
     2383      if (track->subtitle_type == MATROSKA_SUBTYPE_SSA)
     2384        {
     2385      track->sh_sub.ass_track = ass_new_track(ass_library);
     2386      size = track->private_size;
     2387      m = demux_mkv_decode (track,track->private_data,&buffer,&size,2);
     2388      if (buffer && m)
     2389        {
     2390          free (track->private_data);
     2391          track->private_data = buffer;
     2392          track->private_size = size;
     2393        }
     2394      ass_process_codec_private(track->sh_sub.ass_track, track->private_data, track->private_size);
     2395        }
     2396      else
     2397        {
     2398          track->sh_sub.ass_track = ass_default_track(ass_library);
     2399        }
     2400    }
     2401}
     2402#endif
    22142403
    22152404static int
    2216 demux_mkv_open_sub (demuxer_t *demuxer, mkv_track_t *track)
    2217 {
    2218     if (track->subtitle_type != MATROSKA_SUBTYPE_UNKNOWN)
    2219     {
    2220         if (track->subtitle_type == MATROSKA_SUBTYPE_VOBSUB)
    2221         {
    2222             if (track->private_data != NULL)
     2405demux_mkv_open_sub (demuxer_t *demuxer, mkv_track_t *track, int sid)
     2406{
     2407  if (track->subtitle_type != MATROSKA_SUBTYPE_UNKNOWN)
     2408    {
     2409      sh_sub_t *sh = new_sh_sub_sid(demuxer, track->tnum, sid);
     2410      if ((track->subtitle_type == MATROSKA_SUBTYPE_VOBSUB) ||
     2411          (track->subtitle_type == MATROSKA_SUBTYPE_SSA))
     2412        {
     2413          if (track->private_data != NULL)
    22232414            {
    2224                 demuxer->sub->sh = malloc(sizeof(mkv_sh_sub_t));
    2225                 if (demuxer->sub->sh != NULL)
    2226                     memcpy(demuxer->sub->sh, &track->sh_sub, sizeof(mkv_sh_sub_t));
     2415              if (sh)
     2416                memcpy(sh, &track->sh_sub, sizeof(sh_sub_t));
    22272417            }
    22282418        }
    22292419    }
    2230     else
    2231     {
    2232         dprintf ("[mkv] Subtitle type '%s' is not "
    2233                  "supported.\n", track->codec_id);
    2234         return 1;
    2235     }
    2236 
    2237     return 0;
    2238 }
    2239 
    2240 static void demux_mkv_seek (demuxer_t *demuxer, float rel_seek_secs, /*float audio_delay, */int flags);
     2420  else
     2421    {
     2422      dprintf(MSGTR_MPDEMUX_MKV_SubtitleTypeNotSupported,
     2423              track->codec_id);
     2424      return 1;
     2425    }
     2426
     2427  return 0;
     2428}
     2429
     2430static void demux_mkv_seek (demuxer_t *demuxer, float rel_seek_secs, float audio_delay, int flags);
    22412431
    22422432/** \brief Given a matroska track number and type, find the id that mplayer would ask for.
    … …  
    22472437static int demux_mkv_reverse_id(mkv_demuxer_t *d, int num, int type)
    22482438{
    2249     int i, id;
    2250 
    2251     for (i=0, id=0; i < d->num_tracks; i++)
    2252         if (d->tracks[i] != NULL && d->tracks[i]->type == type) {
    2253             if (d->tracks[i]->tnum == num)
    2254                 return id;
    2255             id++;
    2256         }
    2257 
    2258     return -1;
     2439  int i, id;
     2440 
     2441  for (i=0, id=0; i < d->num_tracks; i++)
     2442    if (d->tracks[i] != NULL && d->tracks[i]->type == type) {
     2443      if (d->tracks[i]->tnum == num)
     2444        return id;
     2445      id++;
     2446    }
     2447 
     2448  return -1;
    22592449}
    22602450
    … …  
    22622452demux_mkv_open (demuxer_t *demuxer)
    22632453{
    2264     stream_t *s = demuxer->stream;
    2265     mkv_demuxer_t *mkv_d;
    2266     mkv_track_t *track;
    2267     int i, version, cont = 0;
    2268     char *str;
     2454  stream_t *s = demuxer->stream;
     2455  mkv_demuxer_t *mkv_d;
     2456  mkv_track_t *track;
     2457  int i, version, cont = 0;
     2458  char *str;
    22692459
    22702460#ifdef USE_ICONV
    2271     subcp_open(NULL);
     2461  subcp_open(NULL);
    22722462#endif
    22732463
    2274     stream_seek(s, s->start_pos);
    2275     str = ebml_read_header (s, &version);
    2276     if (str == NULL || strcmp (str, "matroska") || version > 2)
    2277     {
    2278         dprintf ( "[mkv] no head found\n");
    2279         return 0;
    2280     }
    2281     free (str);
    2282 
    2283     dprintf ("[mkv] Found the head...\n");
    2284 
    2285     if (ebml_read_id (s, NULL) != MATROSKA_ID_SEGMENT)
    2286     {
    2287         dprintf ("[mkv] but no segment :(\n");
    2288         return 0;
    2289     }
    2290     ebml_read_length (s, NULL);  /* return bytes number until EOF */
    2291 
    2292     dprintf ("[mkv] + a segment...\n");
    2293 
    2294     demux_aid_vid_mismatch = 1; // don't identify in new_sh_* since ids don't match
    2295 
    2296     mkv_d = (mkv_demuxer_t *) malloc (sizeof (mkv_demuxer_t));
    2297     memset (mkv_d, 0, sizeof(mkv_demuxer_t));
    2298     demuxer->priv = mkv_d;
    2299     mkv_d->tc_scale = 1000000;
    2300     mkv_d->segment_start = stream_tell (s);
    2301     mkv_d->parsed_cues = (off_t *) malloc (sizeof (off_t));
    2302     mkv_d->parsed_seekhead = (off_t *) malloc (sizeof (off_t));
    2303 
    2304     for (i=0; i < SUB_MAX_TEXT; i++)
    2305         mkv_d->subs.text[i] = (char *) malloc (256);
    2306 
    2307     while (!cont)
    2308     {
    2309         switch (ebml_read_id (s, NULL))
     2464  stream_seek(s, s->start_pos);
     2465  str = ebml_read_header (s, &version);
     2466  if (str == NULL || strcmp (str, "matroska") || version > 2)
     2467    {
     2468      dprintf("[mkv] no head found\n");
     2469      return 0;
     2470    }
     2471  free (str);
     2472
     2473  dprintf("[mkv] Found the head...\n");
     2474
     2475  if (ebml_read_id (s, NULL) != MATROSKA_ID_SEGMENT)
     2476    {
     2477      dprintf("[mkv] but no segment :(\n");
     2478      return 0;
     2479    }
     2480  ebml_read_length (s, NULL);  /* return bytes number until EOF */
     2481
     2482  dprintf("[mkv] + a segment...\n");
     2483
     2484  mkv_d = calloc (1, sizeof (mkv_demuxer_t));
     2485  demuxer->priv = mkv_d;
     2486  mkv_d->tc_scale = 1000000;
     2487  mkv_d->segment_start = stream_tell (s);
     2488  mkv_d->parsed_cues = malloc (sizeof (off_t));
     2489  mkv_d->parsed_seekhead = malloc (sizeof (off_t));
     2490
     2491  for (i=0; i < SUB_MAX_TEXT; i++)
     2492    mkv_d->subs.text[i] = malloc (256);
     2493
     2494  while (!cont)
     2495    {
     2496      switch (ebml_read_id (s, NULL))
    23102497        {
    23112498        case MATROSKA_ID_INFO:
    2312             dprintf ("[mkv] |+ segment information...\n");
    2313             cont = demux_mkv_read_info (demuxer);
     2499          dprintf("[mkv] |+ segment information...\n");
     2500          cont = demux_mkv_read_info (demuxer);
     2501          break;
     2502
     2503        case MATROSKA_ID_TRACKS:
     2504          dprintf("[mkv] |+ segment tracks...\n");
     2505          cont = demux_mkv_read_tracks (demuxer);
     2506          break;
     2507
     2508        case MATROSKA_ID_CUES:
     2509          cont = demux_mkv_read_cues (demuxer);
     2510          break;
     2511
     2512        case MATROSKA_ID_TAGS:
     2513          cont = demux_mkv_read_tags (demuxer);
     2514          break;
     2515
     2516        case MATROSKA_ID_SEEKHEAD:
     2517          cont = demux_mkv_read_seekhead (demuxer);
     2518          break;
     2519
     2520        case MATROSKA_ID_CHAPTERS:
     2521          cont = demux_mkv_read_chapters (demuxer);
     2522          break;
     2523
     2524        case MATROSKA_ID_ATTACHMENTS:
     2525          cont = demux_mkv_read_attachments (demuxer);
     2526          break;
     2527
     2528        case MATROSKA_ID_CLUSTER:
     2529          {
     2530            int p, l;
     2531            dprintf("[mkv] |+ found cluster, headers are "
     2532                    "parsed completely :)\n");
     2533            /* get the first cluster timecode */
     2534            p = stream_tell(s);
     2535            l = ebml_read_length (s, NULL);
     2536            while (ebml_read_id (s, NULL) != MATROSKA_ID_CLUSTERTIMECODE)
     2537              {
     2538                ebml_read_skip (s, NULL);
     2539                if (stream_tell (s) >= p + l)
     2540                  break;
     2541              }
     2542            if (stream_tell (s) < p + l)
     2543              {
     2544                uint64_t num = ebml_read_uint (s, NULL);
     2545                if (num == EBML_UINT_INVALID)
     2546                  return 0;
     2547                mkv_d->first_tc = num * mkv_d->tc_scale / 1000000.0;
     2548                mkv_d->has_first_tc = 1;
     2549              }
     2550            stream_seek (s, p - 4);
     2551            cont = 1;
    23142552            break;
    2315 
    2316         case MATROSKA_ID_TRACKS:
    2317             dprintf ("[mkv] |+ segment tracks...\n");
    2318             cont = demux_mkv_read_tracks (demuxer);
     2553          }
     2554
     2555        default:
     2556          cont = 1;
     2557        case EBML_ID_VOID:
     2558          ebml_read_skip (s, NULL);
     2559          break;
     2560        }
     2561    }
     2562
     2563  display_create_tracks (demuxer);
     2564
     2565  /* select video track */
     2566  track = NULL;
     2567  if (demuxer->video->id == -1)  /* automatically select a video track */
     2568    {
     2569      /* search for a video track that has the 'default' flag set */
     2570      for (i=0; i<mkv_d->num_tracks; i++)
     2571        if (mkv_d->tracks[i]->type == MATROSKA_TRACK_VIDEO
     2572            && mkv_d->tracks[i]->default_track)
     2573          {
     2574            track = mkv_d->tracks[i];
    23192575            break;
    2320 
    2321         case MATROSKA_ID_CUES:
    2322             cont = demux_mkv_read_cues (demuxer);
     2576          }
     2577
     2578      if (track == NULL)
     2579        /* no track has the 'default' flag set */
     2580        /* let's take the first video track */
     2581        for (i=0; i<mkv_d->num_tracks; i++)
     2582          if (mkv_d->tracks[i]->type == MATROSKA_TRACK_VIDEO)
     2583            {
     2584              track = mkv_d->tracks[i];
     2585              break;
     2586            }
     2587    }
     2588  else if (demuxer->video->id != -2)  /* -2 = no video at all */
     2589    track = demux_mkv_find_track_by_num (mkv_d, demuxer->video->id,
     2590                                         MATROSKA_TRACK_VIDEO);
     2591
     2592  if (track && demuxer->v_streams[track->tnum])
     2593              {
     2594                dprintf(
     2595                        MSGTR_MPDEMUX_MKV_WillPlayVideoTrack, track->tnum);
     2596                demuxer->video->id = track->tnum;
     2597                demuxer->video->sh = demuxer->v_streams[track->tnum];
     2598              }
     2599  else
     2600    {
     2601      dprintf( MSGTR_MPDEMUX_MKV_NoVideoTrackFound);
     2602      demuxer->video->id = -2;
     2603    }
     2604
     2605  /* select audio track */
     2606  track = NULL;
     2607  if (demuxer->audio->id == -1)  /* automatically select an audio track */
     2608    {
     2609      /* check if the user specified an audio language */
     2610      if (audio_lang != NULL)
     2611        track = demux_mkv_find_track_by_language(mkv_d, audio_lang,
     2612                                                 MATROSKA_TRACK_AUDIO);
     2613      if (track == NULL)
     2614        /* no audio language specified, or language not found */
     2615        /* search for an audio track that has the 'default' flag set */
     2616        for (i=0; i < mkv_d->num_tracks; i++)
     2617          if (mkv_d->tracks[i]->type == MATROSKA_TRACK_AUDIO
     2618              && mkv_d->tracks[i]->default_track)
     2619            {
     2620              track = mkv_d->tracks[i];
     2621              break;
     2622            }
     2623
     2624      if (track == NULL)
     2625        /* no track has the 'default' flag set */
     2626        /* let's take the first audio track */
     2627        for (i=0; i < mkv_d->num_tracks; i++)
     2628          if (mkv_d->tracks[i]->type == MATROSKA_TRACK_AUDIO)
     2629            {
     2630              track = mkv_d->tracks[i];
     2631              break;
     2632            }
     2633    }
     2634  else if (demuxer->audio->id != -2)  /* -2 = no audio at all */
     2635    track = demux_mkv_find_track_by_num (mkv_d, demuxer->audio->id,
     2636                                         MATROSKA_TRACK_AUDIO);
     2637  else
     2638    {
     2639      dprintf( MSGTR_MPDEMUX_MKV_NoAudioTrackFound);
     2640      demuxer->audio->id = -2;
     2641    }
     2642
     2643
     2644  if(demuxer->audio->id != -2)
     2645  for (i=0; i < mkv_d->num_tracks; i++)
     2646    {
     2647      if(mkv_d->tracks[i]->type != MATROSKA_TRACK_AUDIO)
     2648          continue;
     2649      if(demuxer->a_streams[track->tnum])
     2650        {
     2651          if(track && mkv_d->tracks[i] == track)
     2652            {
     2653              demuxer->audio->id = track->tnum;
     2654              demuxer->audio->sh = demuxer->a_streams[track->tnum];
     2655            }
     2656          mkv_d->last_aid++;
     2657          if(mkv_d->last_aid == MAX_A_STREAMS)
    23232658            break;
    2324 
    2325         case MATROSKA_ID_TAGS:
    2326             cont = demux_mkv_read_tags (demuxer);
    2327             break;
    2328 
    2329         case MATROSKA_ID_SEEKHEAD:
    2330             cont = demux_mkv_read_seekhead (demuxer);
    2331             break;
    2332 
    2333         case MATROSKA_ID_CHAPTERS:
    2334             cont = demux_mkv_read_chapters (demuxer);
    2335             break;
    2336 
    2337         case MATROSKA_ID_CLUSTER:
     2659        }
     2660    }
     2661
     2662  demux_mkv_parse_vobsub_data (demuxer);
     2663#ifdef USE_ASS
     2664  if (ass_enabled)
     2665    demux_mkv_parse_ass_data (demuxer);
     2666#endif
     2667  /* DO NOT automatically select a subtitle track and behave like DVD */
     2668  /* playback: only show subtitles if the user explicitely wants them. */
     2669  track = NULL;
     2670  if (demuxer->sub->id >= 0)
     2671    track = demux_mkv_find_track_by_num (mkv_d, demuxer->sub->id,
     2672                                         MATROSKA_TRACK_SUBTITLE);
     2673  else if (dvdsub_lang != NULL)
     2674    track = demux_mkv_find_track_by_language (mkv_d, dvdsub_lang,
     2675                                              MATROSKA_TRACK_SUBTITLE);
     2676
     2677  if (track)
     2678          {
     2679            dprintf(MSGTR_MPDEMUX_MKV_WillDisplaySubtitleTrack, track->tnum);
     2680            dvdsub_id = demux_mkv_reverse_id(mkv_d, track->tnum, MATROSKA_TRACK_SUBTITLE);
     2681            demuxer->sub->id = track->tnum;
     2682          }
     2683  else
     2684    demuxer->sub->id = -2;
     2685
     2686  if (demuxer->chapters)
     2687    {
     2688      for (i=0; i < (int)demuxer->num_chapters; i++)
     2689        {
     2690          demuxer->chapters[i].start -= mkv_d->first_tc;
     2691          demuxer->chapters[i].end -= mkv_d->first_tc;
     2692        }
     2693      if (dvd_last_chapter > 0 && dvd_last_chapter <= demuxer->num_chapters)
     2694        {
     2695          if (demuxer->chapters[dvd_last_chapter-1].end != 0)
     2696            mkv_d->stop_timecode = demuxer->chapters[dvd_last_chapter-1].end;
     2697          else if (dvd_last_chapter + 1 <= demuxer->num_chapters)
     2698            mkv_d->stop_timecode = demuxer->chapters[dvd_last_chapter].start;
     2699        }
     2700    }
     2701
     2702  if (s->end_pos == 0 || (mkv_d->indexes == NULL && index_mode < 0))
     2703    demuxer->seekable = 0;
     2704  else
     2705    {
     2706      demuxer->movi_start = s->start_pos;
     2707      demuxer->movi_end = s->end_pos;
     2708      demuxer->seekable = 1;
     2709      if (demuxer->chapters && dvd_chapter>1 && dvd_chapter<=demuxer->num_chapters)
     2710        {
     2711          if (!mkv_d->has_first_tc)
    23382712            {
    2339                 int p, l;
    2340                 dprintf ("[mkv] |+ found cluster, headers are "
    2341                          "parsed completely :)\n");
    2342                 /* get the first cluster timecode */
    2343                 p = stream_tell(s);
    2344                 l = ebml_read_length (s, NULL);
    2345                 while (ebml_read_id (s, NULL) != MATROSKA_ID_CLUSTERTIMECODE)
    2346                 {
    2347                     ebml_read_skip (s, NULL);
    2348                     if (stream_tell (s) >= p + l)
    2349                         break;
    2350                 }
    2351                 if (stream_tell (s) < p + l)
    2352                 {
    2353                     uint64_t num = ebml_read_uint (s, NULL);
    2354                     if (num == EBML_UINT_INVALID)
    2355                         return 0;
    2356                     mkv_d->first_tc = num * mkv_d->tc_scale / 1000000.0;
    2357                     mkv_d->has_first_tc = 1;
    2358                 }
    2359                 stream_seek (s, p - 4);
    2360                 cont = 1;
    2361                 break;
     2713              mkv_d->first_tc = 0;
     2714              mkv_d->has_first_tc = 1;
    23622715            }
    2363 
    2364         default:
    2365             cont = 1;
    2366         case MATROSKA_ID_ATTACHMENTS:
    2367         case EBML_ID_VOID:
    2368             ebml_read_skip (s, NULL);
    2369             break;
    2370         }
    2371     }
    2372 
    2373     display_tracks (mkv_d);
    2374 
    2375     /* select video track */
    2376     track = NULL;
    2377     if (demuxer->video->id == -1)  /* automatically select a video track */
    2378     {
    2379         /* search for a video track that has the 'default' flag set */
    2380         for (i=0; i<mkv_d->num_tracks; i++)
    2381             if (mkv_d->tracks[i]->type == MATROSKA_TRACK_VIDEO
    2382                 && mkv_d->tracks[i]->default_track)
    2383             {
    2384                 track = mkv_d->tracks[i];
    2385                 break;
    2386             }
    2387 
    2388         if (track == NULL)
    2389             /* no track has the 'default' flag set */
    2390             /* let's take the first video track */
    2391             for (i=0; i<mkv_d->num_tracks; i++)
    2392                 if (mkv_d->tracks[i]->type == MATROSKA_TRACK_VIDEO)
    2393                 {
    2394                     track = mkv_d->tracks[i];
    2395                     break;
    2396                 }
    2397     }
    2398     else if (demuxer->video->id != -2)  /* -2 = no video at all */
    2399         track = demux_mkv_find_track_by_num (mkv_d, demuxer->video->id,
    2400                                              MATROSKA_TRACK_VIDEO);
    2401     else
    2402     {
    2403         dprintf("[mkv] No audio track found/wanted.\n");
    2404         demuxer->audio->id = -2;
    2405     }
    2406 
    2407     if(demuxer->audio->id != -2)
    2408         for (i=0; i < mkv_d->num_tracks; i++)
    2409         {
    2410             if(mkv_d->tracks[i]->type != MATROSKA_TRACK_AUDIO)
    2411                 continue;
    2412             if(!demux_mkv_open_audio (demuxer, mkv_d->tracks[i]))
    2413             {
    2414                 if(track && mkv_d->tracks[i] == track)
    2415                 {
    2416                     demuxer->video->id = track->tnum;
    2417                     demuxer->video->sh = demuxer->v_streams[track->tnum];
    2418                 }
    2419                 mkv_d->last_aid++;
    2420                 if(mkv_d->last_aid == MAX_A_STREAMS)
    2421                     break;
    2422             }
    2423         }
    2424 
    2425     /* select audio track */
    2426     track = NULL;
    2427     if (demuxer->audio->id == -1)  /* automatically select an audio track */
    2428     {
    2429         /* check if the user specified an audio language */
    2430         if (audio_lang != NULL)
    2431             track = demux_mkv_find_track_by_language(mkv_d, audio_lang,
    2432                                                      MATROSKA_TRACK_AUDIO);
    2433         if (track == NULL)
    2434             /* no audio language specified, or language not found */
    2435             /* search for an audio track that has the 'default' flag set */
    2436             for (i=0; i < mkv_d->num_tracks; i++)
    2437                 if (mkv_d->tracks[i]->type == MATROSKA_TRACK_AUDIO
    2438                     && mkv_d->tracks[i]->default_track)
    2439                 {
    2440                     track = mkv_d->tracks[i];
    2441                     break;
    2442                 }
    2443 
    2444         if (track == NULL)
    2445             /* no track has the 'default' flag set */
    2446             /* let's take the first audio track */
    2447             for (i=0; i < mkv_d->num_tracks; i++)
    2448                 if (mkv_d->tracks[i]->type == MATROSKA_TRACK_AUDIO)
    2449                 {
    2450                     track = mkv_d->tracks[i];
    2451                     break;
    2452                 }
    2453     }
    2454     else if (demuxer->audio->id != -2)  /* -2 = no audio at all */
    2455         track = demux_mkv_find_track_by_num (mkv_d, demuxer->audio->id,
    2456                                              MATROSKA_TRACK_AUDIO);
    2457 
    2458     if (track && !demux_mkv_open_audio (demuxer, track))
    2459     {
    2460         dprintf (
    2461                  "[mkv] Will play audio track %u\n", track->tnum);
    2462         demuxer->audio->id = track->tnum;
    2463         demuxer->audio->sh = demuxer->a_streams[track->tnum];
    2464     }
    2465     else
    2466     {
    2467         dprintf ("[mkv] No audio track found/wanted.\n");
    2468         demuxer->audio->id = -2;
    2469     }
    2470 
    2471     demux_mkv_parse_vobsub_data (demuxer);
    2472     /* DO NOT automatically select a subtitle track and behave like DVD */
    2473     /* playback: only show subtitles if the user explicitely wants them. */
    2474     track = NULL;
    2475     if (demuxer->sub->id >= 0)
    2476         track = demux_mkv_find_track_by_num (mkv_d, demuxer->sub->id,
    2477                                              MATROSKA_TRACK_SUBTITLE);
    2478     else if (dvdsub_lang != NULL)
    2479         track = demux_mkv_find_track_by_language (mkv_d, dvdsub_lang,
    2480                                                   MATROSKA_TRACK_SUBTITLE);
    2481 
    2482     if (track && !demux_mkv_open_sub (demuxer, track))
    2483     {
    2484         dprintf (
    2485                  "[mkv] Will display subtitle track %u\n", track->tnum);
    2486         //dvdsub_id = demux_mkv_reverse_id(mkv_d, track->tnum, MATROSKA_TRACK_SUBTITLE);
    2487         demuxer->sub->id = track->tnum;
    2488     }
    2489     else
    2490         demuxer->sub->id = -2;
    2491 
    2492     if (demuxer->chapters)
    2493     {
    2494         for (i=0; i < (int)demuxer->num_chapters; i++)
    2495         {
    2496             demuxer->chapters[i].start -= mkv_d->first_tc;
    2497             demuxer->chapters[i].end -= mkv_d->first_tc;
    2498         }
    2499         if (dvd_last_chapter > 0 && dvd_last_chapter <= demuxer->num_chapters)
    2500         {
    2501             if (demuxer->chapters[dvd_last_chapter-1].end != 0)
    2502                 mkv_d->stop_timecode = demuxer->chapters[dvd_last_chapter-1].end;
    2503             else if (dvd_last_chapter + 1 <= demuxer->num_chapters)
    2504                 mkv_d->stop_timecode = demuxer->chapters[dvd_last_chapter].start;
    2505         }
    2506     }
    2507 
    2508     if (s->end_pos == 0 || (mkv_d->indexes == NULL && index_mode < 0))
    2509         demuxer->seekable = 0;
    2510     else
    2511     {
    2512         demuxer->movi_start = s->start_pos;
    2513         demuxer->movi_end = s->end_pos;
    2514         demuxer->seekable = 1;
    2515         if (demuxer->chapters && dvd_chapter>1 && dvd_chapter<=demuxer->num_chapters)
    2516         {
    2517             if (!mkv_d->has_first_tc)
    2518             {
    2519                 mkv_d->first_tc = 0;
    2520                 mkv_d->has_first_tc = 1;
    2521             }
    2522             demux_mkv_seek (demuxer,
    2523                             demuxer->chapters[dvd_chapter-1].start/1000.0, /*0.0,*/ 1);
    2524         }
    2525     }
    2526 
    2527     return DEMUXER_TYPE_MATROSKA;
     2716          demux_mkv_seek (demuxer,
     2717                          demuxer->chapters[dvd_chapter-1].start/1000.0, 0.0, 1);
     2718        }
     2719    }
     2720
     2721  return DEMUXER_TYPE_MATROSKA;
    25282722}
    25292723
    … …  
    25312725demux_close_mkv (demuxer_t *demuxer)
    25322726{
    2533     mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
    2534 
    2535     if (mkv_d)
    2536     {
    2537         int i;
     2727  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
     2728
     2729  if (mkv_d)
     2730    {
     2731      int i;
    25382732#ifdef USE_ICONV
    2539         subcp_close();
     2733      subcp_close();
    25402734#endif
    2541         free_cached_dps (demuxer);
    2542         if (mkv_d->tracks)
    2543         {
    2544             for (i=0; i<mkv_d->num_tracks; i++)
    2545                 demux_mkv_free_trackentry(mkv_d->tracks[i]);
    2546             for (i=0; i < SUB_MAX_TEXT; i++)
    2547                 if (mkv_d->subs.text[i])
    2548                     free (mkv_d->subs.text[i]);
    2549             free (mkv_d->tracks);
    2550         }
    2551         if (mkv_d->indexes)
    2552             free (mkv_d->indexes);
    2553         if (mkv_d->cluster_positions)
    2554             free (mkv_d->cluster_positions);
    2555         if (mkv_d->parsed_cues)
    2556             free (mkv_d->parsed_cues);
    2557         if (mkv_d->parsed_seekhead)
    2558             free (mkv_d->parsed_seekhead);
    2559         free (mkv_d);
     2735      free_cached_dps (demuxer);
     2736      if (mkv_d->tracks)
     2737        {
     2738          for (i=0; i<mkv_d->num_tracks; i++)
     2739            demux_mkv_free_trackentry(mkv_d->tracks[i]);
     2740          for (i=0; i < SUB_MAX_TEXT; i++)
     2741            if (mkv_d->subs.text[i])
     2742              free (mkv_d->subs.text[i]);
     2743          free (mkv_d->tracks);
     2744        }
     2745      if (mkv_d->indexes)
     2746        free (mkv_d->indexes);
     2747      if (mkv_d->cluster_positions)
     2748        free (mkv_d->cluster_positions);
     2749      if (mkv_d->parsed_cues)
     2750        free (mkv_d->parsed_cues);
     2751      if (mkv_d->parsed_seekhead)
     2752        free (mkv_d->parsed_seekhead);
     2753      if (mkv_d->attachments) {
     2754        for (i = 0; i < mkv_d->num_attachments; ++i) {
     2755          if (mkv_d->attachments[i].name)
     2756            free (mkv_d->attachments[i].name);
     2757          if (mkv_d->attachments[i].mime)
     2758            free (mkv_d->attachments[i].mime);
     2759          if (mkv_d->attachments[i].data)
     2760            free (mkv_d->attachments[i].data);
     2761        }
     2762        free (mkv_d->attachments);
     2763      }
     2764      free (mkv_d);
    25602765    }
    25612766}
    … …  
    25652770                             uint8_t *laces, uint32_t **all_lace_sizes)
    25662771{
    2567     uint32_t total = 0, *lace_size;
    2568     uint8_t flags;
    2569     int i;
    2570 
    2571     *all_lace_sizes = NULL;
    2572     lace_size = NULL;
    2573     /* lacing flags */
    2574     flags = *buffer++;
    2575     (*size)--;
    2576 
    2577     switch ((flags & 0x06) >> 1)
     2772  uint32_t total = 0, *lace_size;
     2773  uint8_t flags;
     2774  int i;
     2775
     2776  *all_lace_sizes = NULL;
     2777  lace_size = NULL;
     2778  /* lacing flags */
     2779  flags = *buffer++;
     2780  (*size)--;
     2781
     2782  switch ((flags & 0x06) >> 1)
    25782783    {
    25792784    case 0:  /* no lacing */
    2580         *laces = 1;
    2581         lace_size = (uint32_t *)calloc(*laces, sizeof(uint32_t));
    2582         lace_size[0] = *size;
    2583         break;
     2785      *laces = 1;
     2786      lace_size = calloc(*laces, sizeof(uint32_t));
     2787      lace_size[0] = *size;
     2788      break;
    25842789
    25852790    case 1:  /* xiph lacing */
    25862791    case 2:  /* fixed-size lacing */
    25872792    case 3:  /* EBML lacing */
    2588         *laces = *buffer++;
    2589         (*size)--;
    2590         (*laces)++;
    2591         lace_size = (uint32_t *)calloc(*laces, sizeof(uint32_t));
    2592 
    2593         switch ((flags & 0x06) >> 1)
     2793      *laces = *buffer++;
     2794      (*size)--;
     2795      (*laces)++;
     2796      lace_size = calloc(*laces, sizeof(uint32_t));
     2797
     2798      switch ((flags & 0x06) >> 1)
    25942799        {
    25952800        case 1:  /* xiph lacing */
    2596             for (i=0; i < *laces-1; i++)
     2801          for (i=0; i < *laces-1; i++)
    25972802            {
    2598                 lace_size[i] = 0;
    2599                 do
     2803              lace_size[i] = 0;
     2804              do
    26002805                {
    2601                     lace_size[i] += *buffer;
    2602                     (*size)--;
     2806                  lace_size[i] += *buffer;
     2807                  (*size)--;
    26032808                } while (*buffer++ == 0xFF);
    2604                 total += lace_size[i];
     2809              total += lace_size[i];
    26052810            }
    2606             lace_size[i] = *size - total;
    2607             break;
     2811          lace_size[i] = *size - total;
     2812          break;
    26082813
    26092814        case 2:  /* fixed-size lacing */
    2610             for (i=0; i < *laces; i++)
    2611                 lace_size[i] = *size / *laces;
    2612             break;
     2815          for (i=0; i < *laces; i++)
     2816            lace_size[i] = *size / *laces;
     2817          break;
    26132818
    26142819        case 3:  /* EBML lacing */
    2615             {
    2616                 int l;
    2617                 uint64_t num = ebml_read_vlen_uint (buffer, &l);
    2618                 if (num == EBML_UINT_INVALID) {
    2619                     free(lace_size);
    2620                     return 1;
     2820          {
     2821            int l;
     2822            uint64_t num = ebml_read_vlen_uint (buffer, &l);
     2823            if (num == EBML_UINT_INVALID) {
     2824              free(lace_size);
     2825              return 1;
     2826            }
     2827            buffer += l;
     2828            *size -= l;
     2829
     2830            total = lace_size[0] = num;
     2831            for (i=1; i < *laces-1; i++)
     2832              {
     2833                int64_t snum;
     2834                snum = ebml_read_vlen_int (buffer, &l);
     2835                if (snum == EBML_INT_INVALID) {
     2836                  free(lace_size);
     2837                  return 1;
    26212838                }
    26222839                buffer += l;
    26232840                *size -= l;
    2624 
    2625                 total = lace_size[0] = num;
    2626                 for (i=1; i < *laces-1; i++)
    2627                 {
    2628                     int64_t snum;
    2629                     snum = ebml_read_vlen_int (buffer, &l);
    2630                     if (snum == EBML_INT_INVALID) {
    2631                         free(lace_size);
    2632                         return 1;
    2633                     }
    2634                     buffer += l;
    2635                     *size -= l;
    2636                     lace_size[i] = lace_size[i-1] + snum;
    2637                     total += lace_size[i];
    2638                 }
    2639                 lace_size[i] = *size - total;
    2640                 break;
    2641             }
    2642         }
    2643         break;
    2644     }
    2645     *all_lace_sizes = lace_size;
    2646     return 0;
    2647 }
     2841                lace_size[i] = lace_size[i-1] + snum;
     2842                total += lace_size[i];
     2843              }
     2844            lace_size[i] = *size - total;
     2845            break;
     2846          }
     2847        }
     2848      break;
     2849    }
     2850  *all_lace_sizes = lace_size;
     2851  return 0;
     2852}
     2853
     2854static void
     2855clear_subtitles(demuxer_t *demuxer, uint64_t timecode, int clear_all);
    26482856
    26492857static void
    … …  
    26512859                 int64_t size, uint64_t block_duration, uint64_t timecode)
    26522860{
    2653     mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
    2654     char *ptr1, *ptr2;
    2655     int state, i;
    2656 
    2657     if (block_duration == 0)
    2658     {
    2659         dprintf ( "[mkv] Warning: No BlockDuration "
    2660                  "for subtitle track found.\n");
     2861  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
     2862  char *ptr1, *ptr2;
     2863  int state, i;
     2864
     2865  if (block_duration == 0)
     2866    {
     2867      dprintf(
     2868              MSGTR_MPDEMUX_MKV_NoBlockDurationForSubtitleTrackFound);
     2869      return;
     2870    }
     2871
     2872#ifdef USE_ASS
     2873  if (ass_enabled && track->subtitle_type == MATROSKA_SUBTYPE_SSA) {
     2874    ass_process_chunk(track->sh_sub.ass_track, block, size, (long long)timecode, (long long)block_duration);
     2875    return;
     2876  }
     2877  clear_subtitles(demuxer, timecode, 1);
     2878#endif
     2879
     2880  ptr1 = block;
     2881  while (ptr1 - block <= size && (*ptr1 == '\n' || *ptr1 == '\r'))
     2882    ptr1++;
     2883  ptr2 = block + size - 1;
     2884  while (ptr2 >= block && (*ptr2 == '\n' || *ptr2 == '\r'))
     2885    {
     2886      *ptr2 = 0;
     2887      ptr2--;
     2888    }
     2889
     2890  if (mkv_d->subs.lines > SUB_MAX_TEXT - 2)
     2891    {
     2892      dprintf(
     2893              MSGTR_MPDEMUX_MKV_TooManySublines);
     2894      return;
     2895    }
     2896  ptr2 = mkv_d->subs.text[mkv_d->subs.lines];
     2897  state = 0;
     2898
     2899  if (track->subtitle_type == MATROSKA_SUBTYPE_SSA)
     2900    {
     2901      /* Find text section. */
     2902      for (i=0; i < 8 && *ptr1 != '\0'; ptr1++)
     2903        if (*ptr1 == ',')
     2904          i++;
     2905      if (*ptr1 == '\0')  /* Broken line? */
    26612906        return;
    2662     }
    2663 
    2664     ptr1 = block;
    2665     while (ptr1 - block <= size && (*ptr1 == '\n' || *ptr1 == '\r'))
    2666         ptr1++;
    2667     ptr2 = block + size - 1;
    2668     while (ptr2 >= block && (*ptr2 == '\n' || *ptr2 == '\r'))
    2669     {
    2670         *ptr2 = 0;
    2671         ptr2--;
    2672     }
    2673 
    2674     if (mkv_d->subs.lines > SUB_MAX_TEXT - 2)
    2675     {
    2676         dprintf ( "[mkv] Warning: too many sublines "
    2677                  "to render, skipping\n");
    2678         return;
    2679     }
    2680     ptr2 = mkv_d->subs.text[mkv_d->subs.lines];
    2681     state = 0;
    2682 
    2683     if (track->subtitle_type == MATROSKA_SUBTYPE_SSA)
    2684     {
    2685         /* Find text section. */
    2686         for (i=0; i < 8 && *ptr1 != '\0'; ptr1++)
    2687             if (*ptr1 == ',')
    2688                 i++;
    2689         if (*ptr1 == '\0')  /* Broken line? */
    2690             return;
    2691 
    2692         /* Load text. */
    2693         while (ptr1 - block < size)
    2694         {
    2695             if (*ptr1 == '{')
    2696                 state = 1;
    2697             else if (*ptr1 == '}' && state == 1)
    2698                 state = 2;
    2699 
    2700             if (state == 0)
     2907
     2908      /* Load text. */
     2909      while (ptr1 - block < size)
     2910        {
     2911          if (*ptr1 == '{')
     2912            state = 1;
     2913          else if (*ptr1 == '}' && state == 1)
     2914            state = 2;
     2915
     2916          if (state == 0)
    27012917            {
    2702                 *ptr2++ = *ptr1;
    2703                 if (ptr2 - mkv_d->subs.text[mkv_d->subs.lines] >= 255)
    2704                     break;
     2918              *ptr2++ = *ptr1;
     2919              if (ptr2 - mkv_d->subs.text[mkv_d->subs.lines] >= 255)
     2920                break;
    27052921            }
    2706             ptr1++;
    2707 
    2708             /* Newline */
    2709             while (*ptr1 == '\\' && ptr1+1-block < size && (*(ptr1+1)|0x20) == 'n')
     2922          ptr1++;
     2923     
     2924          /* Newline */
     2925          while (ptr1+1-block < size && *ptr1 == '\\' && (*(ptr1+1)|0x20) == 'n')
    27102926            {
    2711                 mkv_d->clear_subs_at[mkv_d->subs.lines++]
     2927              mkv_d->clear_subs_at[mkv_d->subs.lines++]
     2928                = timecode + block_duration;
     2929              *ptr2 = '\0';
     2930              if (mkv_d->subs.lines >= SUB_MAX_TEXT)
     2931                {
     2932                  dprintf(
     2933                          MSGTR_MPDEMUX_MKV_TooManySublinesSkippingAfterFirst,
     2934                          SUB_MAX_TEXT);
     2935                  mkv_d->subs.lines--;
     2936                  ptr1=block+size;
     2937                  break;
     2938                }
     2939              ptr2 = mkv_d->subs.text[mkv_d->subs.lines];
     2940              ptr1 += 2;
     2941            }
     2942
     2943          if (state == 2)
     2944            state = 0;
     2945        }
     2946      *ptr2 = '\0';
     2947    }
     2948  else
     2949    {
     2950      while (ptr1 - block < size)
     2951        {
     2952          if (*ptr1 == '\n' || *ptr1 == '\r')
     2953            {
     2954              if (state == 0)  /* normal char --> newline */
     2955                {
     2956                  *ptr2 = '\0';
     2957                  mkv_d->clear_subs_at[mkv_d->subs.lines++]
    27122958                    = timecode + block_duration;
    2713                 *ptr2 = '\0';
    2714                 if (mkv_d->subs.lines >= SUB_MAX_TEXT)
    2715                 {
    2716                     dprintf ( "\n[mkv] Warning: too many "
    2717                              "sublines to render, skipping after first %i\n",
    2718                              SUB_MAX_TEXT);
    2719                     mkv_d->subs.lines--;
    2720                     ptr1=block+size;
    2721                     break;
    2722                 }
    2723                 ptr2 = mkv_d->subs.text[mkv_d->subs.lines];
    2724                 ptr1 += 2;
    2725             }
    2726 
    2727             if (state == 2)
    2728                 state = 0;
    2729         }
    2730         *ptr2 = '\0';
    2731     }
    2732     else
    2733     {
    2734         while (ptr1 - block < size)
    2735         {
    2736             if (*ptr1 == '\n' || *ptr1 == '\r')
    2737             {
    2738                 if (state == 0)  /* normal char --> newline */
    2739                 {
    2740                     *ptr2 = '\0';
    2741                     mkv_d->clear_subs_at[mkv_d->subs.lines++]
    2742                         = timecode + block_duration;
    2743                     if (mkv_d->subs.lines >= SUB_MAX_TEXT)
     2959                  if (mkv_d->subs.lines >= SUB_MAX_TEXT)
    27442960                    {
    2745                         dprintf ( "\n[mkv] Warning: too many "
    2746                                  "sublines to render, skipping after first %i\n",
    2747                                  SUB_MAX_TEXT);
    2748                         mkv_d->subs.lines--;
    2749                         ptr1=block+size;
    2750                         break;
     2961                        dprintf("[mkv]: too many sublines skipping after first\n");
     2962                      mkv_d->subs.lines--;
     2963                      ptr1=block+size;
     2964                      break;
    27512965                    }
    2752                     ptr2 = mkv_d->subs.text[mkv_d->subs.lines];
    2753                     state = 1;
     2966                  ptr2 = mkv_d->subs.text[mkv_d->subs.lines];
     2967                  state = 1;
    27542968                }
    27552969            }
    2756             else if (*ptr1 == '<')  /* skip HTML tags */
    2757                 state = 2;
    2758             else if (*ptr1 == '>')
    2759                 state = 0;
    2760             else if (state != 2)  /* normal character */
     2970          else if (*ptr1 == '<')  /* skip HTML tags */
     2971            state = 2;
     2972          else if (*ptr1 == '>')
     2973            state = 0;
     2974          else if (state != 2)  /* normal character */
    27612975            {
    2762                 state = 0;
    2763                 if ((ptr2 - mkv_d->subs.text[mkv_d->subs.lines]) < 255)
    2764                     *ptr2++ = *ptr1;
     2976              state = 0;
     2977              if ((ptr2 - mkv_d->subs.text[mkv_d->subs.lines]) < 255)
     2978                *ptr2++ = *ptr1;
    27652979            }
    2766             ptr1++;
    2767         }
    2768         *ptr2 = '\0';
    2769     }
    2770     mkv_d->clear_subs_at[mkv_d->subs.lines++] = timecode + block_duration;
    2771 
    2772 #ifdef USE_ICONV
    2773     subcp_recode1 (&mkv_d->subs);
     2980          ptr1++;
     2981        }
     2982      *ptr2 = '\0';
     2983    }
     2984  mkv_d->clear_subs_at[mkv_d->subs.lines++] = timecode + block_duration;
     2985
     2986  //sub_utf8 = 1;
     2987#ifdef USE_ASS
     2988  if (ass_enabled) {
     2989    mkv_d->subs.start = timecode / 10;
     2990    mkv_d->subs.end = (timecode + block_duration) / 10;
     2991    ass_process_subtitle(track->sh_sub.ass_track, &mkv_d->subs);
     2992  } else
    27742993#endif
    2775     //sub_utf8 = 1;
    2776     vo_sub = &mkv_d->subs;
    2777     vo_osd_changed (OSDTYPE_SUBTITLE);
     2994  vo_sub = &mkv_d->subs;
     2995  vo_osd_changed (OSDTYPE_SUBTITLE);
    27782996}
    27792997
    … …  
    27812999clear_subtitles(demuxer_t *demuxer, uint64_t timecode, int clear_all)
    27823000{
    2783     mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
    2784     int i, lines_cut = 0;
    2785     char *tmp;
    2786 
    2787     /* Clear all? */
    2788     if (clear_all)
    2789     {
    2790         lines_cut = mkv_d->subs.lines;
    2791         mkv_d->subs.lines = 0;
    2792         if (lines_cut)
    2793         {
    2794             vo_sub = &mkv_d->subs;
    2795             vo_osd_changed (OSDTYPE_SUBTITLE);
    2796         }
    2797         return;
    2798     }
    2799 
    2800     /* Clear the subtitles if they're obsolete now. */
    2801     for (i=0; i < mkv_d->subs.lines; i++)
    2802     {
    2803         if (mkv_d->clear_subs_at[i] <= timecode)
    2804         {
    2805             tmp = mkv_d->subs.text[i];
    2806             memmove (mkv_d->subs.text+i, mkv_d->subs.text+i+1,
    2807                      (mkv_d->subs.lines-i-1) * sizeof (*mkv_d->subs.text));
    2808             memmove (mkv_d->clear_subs_at+i, mkv_d->clear_subs_at+i+1,
    2809                      (mkv_d->subs.lines-i-1) * sizeof (*mkv_d->clear_subs_at));
    2810             mkv_d->subs.text[--mkv_d->subs.lines] = tmp;
    2811             i--;
    2812             lines_cut = 1;
    2813         }
    2814     }
    2815     if (lines_cut)
    2816     {
    2817         vo_sub = &mkv_d->subs;
    2818         vo_osd_changed (OSDTYPE_SUBTITLE);
     3001  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
     3002  int i, lines_cut = 0;
     3003  char *tmp;
     3004
     3005  /* Clear all? */
     3006  if (clear_all)
     3007    {
     3008      lines_cut = mkv_d->subs.lines;
     3009      mkv_d->subs.lines = 0;
     3010#ifdef USE_ASS
     3011      if (!ass_enabled)
     3012#endif
     3013      if (lines_cut)
     3014        {
     3015          vo_sub = &mkv_d->subs;
     3016          vo_osd_changed (OSDTYPE_SUBTITLE);
     3017        }
     3018      return;
     3019    }
     3020
     3021  /* Clear the subtitles if they're obsolete now. */
     3022  for (i=0; i < mkv_d->subs.lines; i++)
     3023    {
     3024      if (mkv_d->clear_subs_at[i] <= timecode)
     3025        {
     3026          tmp = mkv_d->subs.text[i];
     3027          memmove (mkv_d->subs.text+i, mkv_d->subs.text+i+1,
     3028                   (mkv_d->subs.lines-i-1) * sizeof (*mkv_d->subs.text));
     3029          memmove (mkv_d->clear_subs_at+i, mkv_d->clear_subs_at+i+1,
     3030                   (mkv_d->subs.lines-i-1) * sizeof (*mkv_d->clear_subs_at));
     3031          mkv_d->subs.text[--mkv_d->subs.lines] = tmp;
     3032          i--;
     3033          lines_cut = 1;
     3034        }
     3035    }
     3036#ifdef USE_ASS
     3037  if (!ass_enabled)
     3038#endif
     3039  if (lines_cut)
     3040    {
     3041      vo_sub = &mkv_d->subs;
     3042      vo_osd_changed (OSDTYPE_SUBTITLE);
    28193043    }
    28203044}
    … …  
    28263050static float real_fix_timestamp(mkv_track_t *track, unsigned char *s,
    28273051                                int timestamp) {
    2828     float v_pts;
    2829     uint32_t buffer = (s[0] << 24) + (s[1] << 16) + (s[2] << 8) + s[3];
    2830     int kf = timestamp;
    2831     int pict_type;
    2832     int orig_kf;
    2833 
    2834     if (!strcmp(track->codec_id, MKV_V_REALV30) ||
    2835         !strcmp(track->codec_id, MKV_V_REALV40)) {
    2836 
    2837         if (!strcmp(track->codec_id, MKV_V_REALV30)) {
    2838             SKIP_BITS(3);
    2839             pict_type = SHOW_BITS(2);
    2840             SKIP_BITS(2 + 7);
    2841         }else{
    2842             SKIP_BITS(1);
    2843             pict_type = SHOW_BITS(2);
    2844             SKIP_BITS(2 + 7 + 3);
    2845         }
    2846         kf = SHOW_BITS(13);         // kf= 2*SHOW_BITS(12);
    2847         orig_kf = kf;
    2848         if (pict_type <= 1) {
    2849             // I frame, sync timestamps:
    2850             track->rv_kf_base = timestamp - kf;
    2851             dprintf("\nTS: base=%08X\n", track->rv_kf_base);
    2852             kf = timestamp;
    2853         } else {
    2854             // P/B frame, merge timestamps:
    2855             int tmp = timestamp - track->rv_kf_base;
    2856             kf |= tmp & (~0x1fff);    // combine with packet timestamp
    2857             if (kf < (tmp - 4096))    // workaround wrap-around problems
    2858                 kf += 8192;
    2859             else if (kf > (tmp + 4096))
    2860                 kf -= 8192;
    2861             kf += track->rv_kf_base;
    2862         }
    2863         if (pict_type != 3) {       // P || I  frame -> swap timestamps
    2864             int tmp = kf;
    2865             kf = track->rv_kf_pts;
    2866             track->rv_kf_pts = tmp;
    2867         }
    2868         dprintf("\nTS: %08X -> %08X (%04X) %d %02X %02X %02X "
    2869                 "%02X %5d\n", timestamp, kf, orig_kf, pict_type, s[0], s[1], s[2],
    2870                 s[3], kf - (int)(1000.0 * track->rv_pts));
    2871     }
    2872     v_pts = kf * 0.001f;
    2873     track->rv_pts = v_pts;
    2874 
    2875     return v_pts;
     3052  float v_pts;
     3053  uint32_t buffer = (s[0] << 24) + (s[1] << 16) + (s[2] << 8) + s[3];
     3054  int kf = timestamp;
     3055  int pict_type;
     3056  int orig_kf;
     3057
     3058  if (!strcmp(track->codec_id, MKV_V_REALV30) ||
     3059      !strcmp(track->codec_id, MKV_V_REALV40)) {
     3060
     3061    if (!strcmp(track->codec_id, MKV_V_REALV30)) {
     3062      SKIP_BITS(3);
     3063      pict_type = SHOW_BITS(2);
     3064      SKIP_BITS(2 + 7);
     3065    }else{
     3066      SKIP_BITS(1);
     3067      pict_type = SHOW_BITS(2);
     3068      SKIP_BITS(2 + 7 + 3);
     3069    }
     3070    kf = SHOW_BITS(13);         // kf= 2*SHOW_BITS(12);
     3071    orig_kf = kf;
     3072    if (pict_type <= 1) {
     3073      // I frame, sync timestamps:
     3074      track->rv_kf_base = timestamp - kf;
     3075      dprintf("\nTS: base=%08X\n", track->rv_kf_base);
     3076      kf = timestamp;
     3077    } else {
     3078      // P/B frame, merge timestamps:
     3079      int tmp = timestamp - track->rv_kf_base;
     3080      kf |= tmp & (~0x1fff);    // combine with packet timestamp
     3081      if (kf < (tmp - 4096))    // workaround wrap-around problems
     3082        kf += 8192;
     3083      else if (kf > (tmp + 4096))
     3084        kf -= 8192;
     3085      kf += track->rv_kf_base;
     3086    }
     3087    if (pict_type != 3) {       // P || I  frame -> swap timestamps
     3088      int tmp = kf;
     3089      kf = track->rv_kf_pts;
     3090      track->rv_kf_pts = tmp;
     3091    }
     3092    dprintf("\nTS: %08X -> %08X (%04X) %d %02X %02X %02X "
     3093           "%02X %5d\n", timestamp, kf, orig_kf, pict_type, s[0], s[1], s[2],
     3094           s[3], kf - (int)(1000.0 * track->rv_pts));
     3095  }
     3096  v_pts = kf * 0.001f;
     3097  track->rv_pts = v_pts;
     3098
     3099  return v_pts;
    28763100}
    28773101
    … …  
    28803104                  uint32_t size, int block_bref)
    28813105{
    2882     mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
    2883     demux_packet_t *dp;
    2884     dp_hdr_t *hdr;
    2885     uint8_t chunks;
    2886     int isize;
     3106  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
     3107  demux_packet_t *dp;
     3108  dp_hdr_t *hdr;
     3109  uint8_t chunks;
     3110  int isize;
    28873111#ifdef WORDS_BIGENDIAN
    2888     uint8_t *p;
    2889     int i;
     3112  uint8_t *p;
     3113  int i;
    28903114#endif
    28913115
    2892     chunks = *buffer++;
    2893     isize = --size - (chunks+1)*8;
    2894     dp = new_demux_packet (sizeof (*hdr) + size);
    2895     memcpy (dp->buffer + sizeof(*hdr), buffer + (chunks+1)*8, isize);
     3116  chunks = *buffer++;
     3117  isize = --size - (chunks+1)*8;
     3118  dp = new_demux_packet (sizeof (*hdr) + size);
     3119  memcpy (dp->buffer + sizeof(*hdr), buffer + (chunks+1)*8, isize);
    28963120#ifdef WORDS_BIGENDIAN
    2897     p = (uint8_t *)(dp->buffer + sizeof(*hdr) + isize);
    2898     for (i = 0; i<(chunks+1)*8; i+=4) {
    2899         p[i] = *((uint8_t *)buffer+i+3);
    2900         p[i+1] = *((uint8_t *)buffer+i+2);
    2901         p[i+2] = *((uint8_t *)buffer+i+1);
    2902         p[i+3] = *((uint8_t *)buffer+i);
    2903     }
     3121  p = (uint8_t *)(dp->buffer + sizeof(*hdr) + isize);
     3122  for (i = 0; i<(chunks+1)*8; i+=4) {
     3123    p[i] = *((uint8_t *)buffer+i+3);
     3124    p[i+1] = *((uint8_t *)buffer+i+2);
     3125    p[i+2] = *((uint8_t *)buffer+i+1);
     3126    p[i+3] = *((uint8_t *)buffer+i);
     3127  }
    29043128#else
    2905     memcpy (dp->buffer + sizeof(*hdr) + isize, buffer, (chunks+1)*8);
     3129  memcpy (dp->buffer + sizeof(*hdr) + isize, buffer, (chunks+1)*8);
    29063130#endif
    29073131
    2908     hdr = (dp_hdr_t *) dp->buffer;
    2909     hdr->len = isize;
    2910     hdr->chunks = chunks;
    2911     hdr->timestamp = mkv_d->last_pts * 1000;
    2912     hdr->chunktab = sizeof(*hdr) + isize;
    2913 
    2914     dp->len = sizeof(*hdr) + size;
    2915     if (mkv_d->v_skip_to_keyframe)
    2916     {
    2917         dp->pts = mkv_d->last_pts;
    2918         track->rv_kf_base = 0;
    2919         track->rv_kf_pts = hdr->timestamp;
    2920     }
    2921     else
    2922         dp->pts = real_fix_timestamp (track, dp->buffer + sizeof(*hdr),
    2923                                       hdr->timestamp);
    2924     dp->pos = demuxer->filepos;
    2925     dp->flags = block_bref ? 0 : 0x10;
    2926 
    2927     ds_add_packet(demuxer->video, dp);
     3132  hdr = (dp_hdr_t *) dp->buffer;
     3133  hdr->len = isize;
     3134  hdr->chunks = chunks;
     3135  hdr->timestamp = mkv_d->last_pts * 1000;
     3136  hdr->chunktab = sizeof(*hdr) + isize;
     3137
     3138  dp->len = sizeof(*hdr) + size;
     3139  if (mkv_d->v_skip_to_keyframe)
     3140    {
     3141      dp->pts = mkv_d->last_pts;
     3142      track->rv_kf_base = 0;
     3143      track->rv_kf_pts = hdr->timestamp;
     3144    }
     3145  else
     3146    dp->pts = real_fix_timestamp (track, dp->buffer + sizeof(*hdr),
     3147                                  hdr->timestamp);
     3148  dp->pos = demuxer->filepos;
     3149  dp->flags = block_bref ? 0 : 0x10;
     3150
     3151  ds_add_packet(demuxer->video, dp);
    29283152}
    29293153
    … …  
    29323156                  uint32_t size, int block_bref)
    29333157{
    2934     mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
    2935     int sps = track->sub_packet_size;
    2936     int sph = track->sub_packet_h;
    2937     int cfs = track->coded_framesize;
    2938     int w = track->audiopk_size;
    2939     int spc = track->sub_packet_cnt;
    2940     demux_packet_t *dp;
    2941     int x;
    2942 
    2943     if ((track->a_formattag == mmioFOURCC('2', '8', '_', '8')) ||
    2944         (track->a_formattag == mmioFOURCC('c', 'o', 'o', 'k')) ||
    2945         (track->a_formattag == mmioFOURCC('a', 't', 'r', 'c')) ||
    2946         (track->a_formattag == mmioFOURCC('s', 'i', 'p', 'r')))
    2947     {
    2948         //      if(!block_bref)
    2949         //        spc = track->sub_packet_cnt = 0;
    2950         switch (track->a_formattag) {
     3158  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
     3159  int sps = track->sub_packet_size;
     3160  int sph = track->sub_packet_h;
     3161  int cfs = track->coded_framesize;
     3162  int w = track->audiopk_size;
     3163  int spc = track->sub_packet_cnt;
     3164  demux_packet_t *dp;
     3165  int x;
     3166
     3167  if ((track->a_formattag == mmioFOURCC('2', '8', '_', '8')) ||
     3168      (track->a_formattag == mmioFOURCC('c', 'o', 'o', 'k')) ||
     3169      (track->a_formattag == mmioFOURCC('a', 't', 'r', 'c')) ||
     3170      (track->a_formattag == mmioFOURCC('s', 'i', 'p', 'r')))
     3171    {
     3172//      if(!block_bref)
     3173//        spc = track->sub_packet_cnt = 0;
     3174      switch (track->a_formattag) {
    29513175        case mmioFOURCC('2', '8', '_', '8'):
    2952             for (x = 0; x < sph / 2; x++)
    2953                 memcpy(track->audio_buf + x * 2 * w + spc * cfs, buffer + cfs * x, cfs);
    2954             break;
     3176          for (x = 0; x < sph / 2; x++)
     3177            memcpy(track->audio_buf + x * 2 * w + spc * cfs, buffer + cfs * x, cfs);
     3178          break;
    29553179        case mmioFOURCC('c', 'o', 'o', 'k'):
    29563180        case mmioFOURCC('a', 't', 'r', 'c'):
    2957             for (x = 0; x < w / sps; x++)
    2958                 memcpy(track->audio_buf + sps * (sph * x + ((sph + 1) / 2) * (spc & 1) + (spc >> 1)), buffer + sps * x, sps);
    2959             break;
     3181          for (x = 0; x < w / sps; x++)
     3182            memcpy(track->audio_buf + sps * (sph * x + ((sph + 1) / 2) * (spc & 1) + (spc >> 1)), buffer + sps * x, sps);
     3183          break;
    29603184        case mmioFOURCC('s', 'i', 'p', 'r'):
    2961             memcpy(track->audio_buf + spc * w, buffer, w);
    2962             if (spc == sph - 1)
     3185          memcpy(track->audio_buf + spc * w, buffer, w);
     3186          if (spc == sph - 1)
    29633187            {
    2964                 int n;
    2965                 int bs = sph * w * 2 / 96;  // nibbles per subpacket
    2966                 // Perform reordering
    2967                 for(n=0; n < 38; n++)
     3188              int n;
     3189              int bs = sph * w * 2 / 96;  // nibbles per subpacket
     3190              // Perform reordering
     3191              for(n=0; n < 38; n++)
    29683192                {
    2969                     int j;
    2970                     int i = bs * sipr_swaps[n][0];
    2971                     int o = bs * sipr_swaps[n][1];
    2972                     // swap nibbles of block 'i' with 'o'      TODO: optimize
    2973                     for(j = 0;j < bs; j++)
     3193                  int j;
     3194                  int i = bs * sipr_swaps[n][0];
     3195                  int o = bs * sipr_swaps[n][1];
     3196                  // swap nibbles of block 'i' with 'o'      TODO: optimize
     3197                  for(j = 0;j < bs; j++)
    29743198                    {
    2975                         int x = (i & 1) ? (track->audio_buf[i >> 1] >> 4) : (track->audio_buf[i >> 1] & 0x0F);
    2976                         int y = (o & 1) ? (track->audio_buf[o >> 1] >> 4) : (track->audio_buf[o >> 1] & 0x0F);
    2977                         if(o & 1)
    2978                             track->audio_buf[o >> 1] = (track->audio_buf[o >> 1] & 0x0F) | (x << 4);
    2979                         else
    2980                             track->audio_buf[o >> 1] = (track->audio_buf[o >> 1] & 0xF0) | x;
    2981                         if(i & 1)
    2982                             track->audio_buf[i >> 1] = (track->audio_buf[i >> 1] & 0x0F) | (y << 4);
    2983                         else
    2984                             track->audio_buf[i >> 1] = (track->audio_buf[i >> 1] & 0xF0) | y;
    2985                         ++i; ++o;
     3199                      int x = (i & 1) ? (track->audio_buf[i >> 1] >> 4) : (track->audio_buf[i >> 1] & 0x0F);
     3200                      int y = (o & 1) ? (track->audio_buf[o >> 1] >> 4) : (track->audio_buf[o >> 1] & 0x0F);
     3201                      if(o & 1)
     3202                        track->audio_buf[o >> 1] = (track->audio_buf[o >> 1] & 0x0F) | (x << 4);
     3203                      else
     3204                        track->audio_buf[o >> 1] = (track->audio_buf[o >> 1] & 0xF0) | x;
     3205                      if(i & 1)
     3206                        track->audio_buf[i >> 1] = (track->audio_buf[i >> 1] & 0x0F) | (y << 4);
     3207                      else
     3208                        track->audio_buf[i >> 1] = (track->audio_buf[i >> 1] & 0xF0) | y;
     3209                      ++i; ++o;
    29863210                    }
    29873211                }
    29883212            }
    2989             break;
    2990         }
    2991         track->audio_timestamp[track->sub_packet_cnt] = (track->ra_pts == mkv_d->last_pts) ? 0 : (mkv_d->last_pts);
    2992         track->ra_pts = mkv_d->last_pts;
    2993         if (track->sub_packet_cnt == 0)
    2994             track->audio_filepos = demuxer->filepos;
    2995         if (++(track->sub_packet_cnt) == sph)
    2996         {
    2997             int apk_usize = ((WAVEFORMATEX*)((sh_audio_t*)demuxer->audio->sh)->wf)->nBlockAlign;
    2998             track->sub_packet_cnt = 0;
    2999             // Release all the audio packets
    3000             for (x = 0; x < sph*w/apk_usize; x++)
    3001             {
    3002                 dp = new_demux_packet(apk_usize);
    3003                 memcpy(dp->buffer, track->audio_buf + x * apk_usize, apk_usize);
    3004                 /* Put timestamp only on packets that correspond to original audio packets in file */
    3005                 dp->pts = (x * apk_usize % w) ? 0 : track->audio_timestamp[x * apk_usize / w];
    3006                 dp->pos = track->audio_filepos; // all equal
    3007                 dp->flags = x ? 0 : 0x10; // Mark first packet as keyframe
    3008                 ds_add_packet(demuxer->audio, dp);
    3009             }
    3010         }
    3011     } else { // Not a codec that require reordering
    3012         dp = new_demux_packet (size);
    3013         memcpy(dp->buffer, buffer, size);
    3014         if (track->ra_pts == mkv_d->last_pts && !mkv_d->a_skip_to_keyframe)
    3015             dp->pts = 0;
    3016         else
    3017             dp->pts = mkv_d->last_pts;
    3018         track->ra_pts = mkv_d->last_pts;
    3019 
    3020         dp->pos = demuxer->filepos;
    3021         dp->flags = block_bref ? 0 : 0x10;
    3022         ds_add_packet (demuxer->audio, dp);
    3023     }
     3213          break;
     3214      }
     3215      track->audio_timestamp[track->sub_packet_cnt] = (track->ra_pts == mkv_d->last_pts) ? 0 : (mkv_d->last_pts);
     3216      track->ra_pts = mkv_d->last_pts;
     3217      if (track->sub_packet_cnt == 0)
     3218        track->audio_filepos = demuxer->filepos;
     3219      if (++(track->sub_packet_cnt) == sph)
     3220        {
     3221           int apk_usize = ((WAVEFORMATEX*)((sh_audio_t*)demuxer->audio->sh)->wf)->nBlockAlign;
     3222           track->sub_packet_cnt = 0;
     3223           // Release all the audio packets
     3224           for (x = 0; x < sph*w/apk_usize; x++)
     3225             {
     3226               dp = new_demux_packet(apk_usize);
     3227               memcpy(dp->buffer, track->audio_buf + x * apk_usize, apk_usize);
     3228               /* Put timestamp only on packets that correspond to original audio packets in file */
     3229               dp->pts = (x * apk_usize % w) ? 0 : track->audio_timestamp[x * apk_usize / w];
     3230               dp->pos = track->audio_filepos; // all equal
     3231               dp->flags = x ? 0 : 0x10; // Mark first packet as keyframe
     3232               ds_add_packet(demuxer->audio, dp);
     3233             }
     3234        }
     3235   } else { // Not a codec that require reordering
     3236  dp = new_demux_packet (size);
     3237  memcpy(dp->buffer, buffer, size);
     3238  if (track->ra_pts == mkv_d->last_pts && !mkv_d->a_skip_to_keyframe)
     3239    dp->pts = 0;
     3240  else
     3241    dp->pts = mkv_d->last_pts;
     3242  track->ra_pts = mkv_d->last_pts;
     3243
     3244  dp->pos = demuxer->filepos;
     3245  dp->flags = block_bref ? 0 : 0x10;
     3246  ds_add_packet (demuxer->audio, dp);
     3247  }
    30243248}
    30253249
    … …  
    30453269flush_cached_dps (demuxer_t *demuxer, mkv_track_t *track)
    30463270{
    3047     int i, ok;
    3048 
    3049     if (track->num_cached_dps == 0)
    3050         return;
    3051 
    3052     do {
    3053         ok = 1;
    3054         for (i = 1; i < track->num_cached_dps; i++)
    3055             if (track->cached_dps[i - 1]->pts > track->cached_dps[i]->pts) {
    3056                 float tmp_pts = track->cached_dps[i - 1]->pts;
    3057                 track->cached_dps[i - 1]->pts = track->cached_dps[i]->pts;
    3058                 track->cached_dps[i]->pts = tmp_pts;
    3059                 ok = 0;
    3060             }
    3061     } while (!ok);
    3062 
    3063     for (i = 0; i < track->num_cached_dps; i++)
    3064         ds_add_packet (demuxer->video, track->cached_dps[i]);
    3065     track->num_cached_dps = 0;
     3271  int i, ok;
     3272
     3273  if (track->num_cached_dps == 0)
     3274    return;
     3275
     3276  do {
     3277    ok = 1;
     3278    for (i = 1; i < track->num_cached_dps; i++)
     3279      if (track->cached_dps[i - 1]->pts > track->cached_dps[i]->pts) {
     3280        float tmp_pts = track->cached_dps[i - 1]->pts;
     3281        track->cached_dps[i - 1]->pts = track->cached_dps[i]->pts;
     3282        track->cached_dps[i]->pts = tmp_pts;
     3283        ok = 0;
     3284      }
     3285  } while (!ok);
     3286
     3287  for (i = 0; i < track->num_cached_dps; i++)
     3288    ds_add_packet (demuxer->video, track->cached_dps[i]);
     3289  track->num_cached_dps = 0;
    30663290}
    30673291
    … …  
    30903314                      uint32_t size, int block_bref, int block_fref)
    30913315{
    3092     mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
    3093     demux_packet_t *dp;
    3094 
    3095     dp = new_demux_packet (size);
    3096     memcpy(dp->buffer, buffer, size);
    3097     dp->pos = demuxer->filepos;
    3098     dp->pts = mkv_d->last_pts;
    3099     if ((track->num_cached_dps > 0) && (dp->pts < track->max_pts))
    3100         block_fref = 1;
    3101     if (block_fref == 0)          /* I or P frame */
    3102         flush_cached_dps (demuxer, track);
    3103     if (block_bref != 0)          /* I frame, don't cache it */
    3104         dp->flags = 0x10;
    3105     if ((track->num_cached_dps + 1) > track->num_allocated_dps)
    3106     {
    3107         track->cached_dps = (demux_packet_t **)
    3108             realloc(track->cached_dps, (track->num_cached_dps + 10) *
    3109                     sizeof(demux_packet_t *));
    3110         track->num_allocated_dps += 10;
    3111     }
    3112     track->cached_dps[track->num_cached_dps] = dp;
    3113     track->num_cached_dps++;
    3114     if (dp->pts > track->max_pts)
    3115         track->max_pts = dp->pts;
     3316  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
     3317  demux_packet_t *dp;
     3318
     3319  dp = new_demux_packet (size);
     3320  memcpy(dp->buffer, buffer, size);
     3321  dp->pos = demuxer->filepos;
     3322  dp->pts = mkv_d->last_pts;
     3323  if ((track->num_cached_dps > 0) && (dp->pts < track->max_pts))
     3324    block_fref = 1;
     3325  if (block_fref == 0)          /* I or P frame */
     3326    flush_cached_dps (demuxer, track);
     3327  if (block_bref != 0)          /* I frame, don't cache it */
     3328    dp->flags = 0x10;
     3329  if ((track->num_cached_dps + 1) > track->num_allocated_dps)
     3330    {
     3331      track->cached_dps = (demux_packet_t **)
     3332        realloc(track->cached_dps, (track->num_cached_dps + 10) *
     3333                sizeof(demux_packet_t *));
     3334      track->num_allocated_dps += 10;
     3335    }
     3336  track->cached_dps[track->num_cached_dps] = dp;
     3337  track->num_cached_dps++;
     3338  if (dp->pts > track->max_pts)
     3339    track->max_pts = dp->pts;
    31163340}
    31173341
    … …  
    31203344              uint64_t block_duration, int64_t block_bref, int64_t block_fref, uint8_t simpleblock)
    31213345{
    3122     mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
    3123     mkv_track_t *track = NULL;
    3124     demux_stream_t *ds = NULL;
    3125     uint64_t old_length;
    3126     int64_t tc;
    3127     uint32_t *lace_size;
    3128     uint8_t laces, flags;
    3129     int i, num, tmp, use_this_block = 1;
    3130     float current_pts;
    3131     int16_t time;
    3132 
    3133     /* first byte(s): track num */
    3134     num = ebml_read_vlen_uint (block, &tmp);
    3135     block += tmp;
    3136     /* time (relative to cluster time) */
    3137     time = block[0] << 8 | block[1];
    3138     block += 2;
    3139     length -= tmp + 2;
    3140     old_length = length;
    3141     flags = block[0];
    3142     if (demux_mkv_read_block_lacing (block, &length, &laces, &lace_size))
    3143         return 0;
    3144     block += old_length - length;
    3145 
    3146     tc = ((time*mkv_d->tc_scale+mkv_d->cluster_tc) /1000000.0 - mkv_d->first_tc);
    3147     if (tc < 0)
    3148         tc = 0;
    3149     if (mkv_d->stop_timecode > 0 && tc > mkv_d->stop_timecode) {
    3150         free(lace_size);
    3151         return -1;
    3152     }
    3153     current_pts = tc / 1000.0;
    3154 
    3155     clear_subtitles(demuxer, tc, 0);
    3156 
    3157     for (i=0; i<mkv_d->num_tracks; i++)
    3158         if (mkv_d->tracks[i]->tnum == num) {
    3159             track = mkv_d->tracks[i];
    3160             break;
    3161         }
    3162     if (track == NULL)
    3163     {
    3164         free(lace_size);
    3165         return 1;
    3166     }
    3167     if (num == demuxer->audio->id)
    3168     {
    3169         ds = demuxer->audio;
    3170 
    3171         if (mkv_d->a_skip_to_keyframe)
    3172         {
    3173             if (simpleblock)
     3346  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
     3347  mkv_track_t *track = NULL;
     3348  demux_stream_t *ds = NULL;
     3349  uint64_t old_length;
     3350  int64_t tc;
     3351  uint32_t *lace_size;
     3352  uint8_t laces, flags;
     3353  int i, num, tmp, use_this_block = 1;
     3354  float current_pts;
     3355  int16_t time;
     3356
     3357  /* first byte(s): track num */
     3358  num = ebml_read_vlen_uint (block, &tmp);
     3359  block += tmp;
     3360  /* time (relative to cluster time) */
     3361  time = block[0] << 8 | block[1];
     3362  block += 2;
     3363  length -= tmp + 2;
     3364  old_length = length;
     3365  flags = block[0];
     3366  if (demux_mkv_read_block_lacing (block, &length, &laces, &lace_size))
     3367    return 0;
     3368  block += old_length - length;
     3369
     3370  tc = ((time*mkv_d->tc_scale+mkv_d->cluster_tc) /1000000.0 - mkv_d->first_tc);
     3371  if (tc < 0)
     3372    tc = 0;
     3373  if (mkv_d->stop_timecode > 0 && tc > mkv_d->stop_timecode) {
     3374    free(lace_size);
     3375    return -1;
     3376  }
     3377  current_pts = tc / 1000.0;
     3378
     3379  clear_subtitles(demuxer, tc, 0);
     3380
     3381  for (i=0; i<mkv_d->num_tracks; i++)
     3382    if (mkv_d->tracks[i]->tnum == num) {
     3383      track = mkv_d->tracks[i];
     3384      break;
     3385    }
     3386  if (track == NULL)
     3387    {
     3388      free(lace_size);
     3389      return 1;
     3390    }
     3391  if (num == demuxer->audio->id)
     3392    {
     3393      ds = demuxer->audio;
     3394
     3395      if (mkv_d->a_skip_to_keyframe)
     3396        {
     3397          if (simpleblock)
    31743398            {
    3175                 if (!(flags&0x80))   /*current frame isn't a keyframe*/
    3176                     use_this_block = 0;
     3399               if (!(flags&0x80))   /*current frame isn't a keyframe*/
     3400                 use_this_block = 0;
    31773401            }
    3178             else if (block_bref != 0)
     3402          else if (block_bref != 0)
     3403            use_this_block = 0;
     3404        }
     3405      else if (mkv_d->v_skip_to_keyframe)
     3406        use_this_block = 0;
     3407
     3408      if (track->fix_i_bps && use_this_block)
     3409        {
     3410          sh_audio_t *sh = (sh_audio_t *) ds->sh;
     3411
     3412          if (block_duration != 0)
     3413            {
     3414              sh->i_bps = length * 1000 / block_duration;
     3415              track->fix_i_bps = 0;
     3416            }
     3417          else if (track->qt_last_a_pts == 0.0)
     3418            track->qt_last_a_pts = current_pts;
     3419          else if(track->qt_last_a_pts != current_pts)
     3420            {
     3421              sh->i_bps = length / (current_pts - track->qt_last_a_pts);
     3422              track->fix_i_bps = 0;
     3423            }
     3424        }
     3425    }
     3426  else if (tc < mkv_d->skip_to_timecode)
     3427    use_this_block = 0;
     3428  else if (num == demuxer->video->id)
     3429    {
     3430      ds = demuxer->video;
     3431      if (mkv_d->v_skip_to_keyframe)
     3432        {
     3433          if (simpleblock)
     3434            {
     3435              if (!(flags&0x80))   /*current frame isn't a keyframe*/
    31793436                use_this_block = 0;
    3180         }
    3181         else if (mkv_d->v_skip_to_keyframe)
     3437            }
     3438          else if (block_bref != 0 || block_fref != 0)
    31823439            use_this_block = 0;
    3183 
    3184         if (track->fix_i_bps && use_this_block)
    3185         {
    3186             sh_audio_t *sh = (sh_audio_t *) ds->sh;
    3187 
    3188             if (block_duration != 0)
     3440        }
     3441    }
     3442  else if (num == demuxer->sub->id)
     3443    {
     3444      ds = demuxer->sub;
     3445      if (track->subtitle_type != MATROSKA_SUBTYPE_VOBSUB)
     3446        {
     3447          if (!mkv_d->v_skip_to_keyframe)
     3448            handle_subtitles (demuxer, track, block, length,
     3449                              block_duration, tc);
     3450          use_this_block = 0;
     3451        }
     3452    }
     3453  else
     3454    use_this_block = 0;
     3455
     3456  if (use_this_block)
     3457    {
     3458      mkv_d->last_pts = current_pts;
     3459      mkv_d->last_filepos = demuxer->filepos;
     3460
     3461      for (i=0; i < laces; i++)
     3462        {
     3463          if (ds == demuxer->video && track->realmedia)
     3464            handle_realvideo (demuxer, track, block, lace_size[i], block_bref);
     3465          else if (ds == demuxer->audio && track->realmedia)
     3466            handle_realaudio (demuxer, track, block, lace_size[i], block_bref);
     3467          else if (ds == demuxer->video && track->reorder_timecodes)
     3468            handle_video_bframes (demuxer, track, block, lace_size[i],
     3469                                  block_bref, block_fref);
     3470          else
    31893471            {
    3190                 sh->i_bps = length * 1000 / block_duration;
    3191                 track->fix_i_bps = 0;
    3192             }
    3193             else if (track->qt_last_a_pts == 0.0)
    3194                 track->qt_last_a_pts = current_pts;
    3195             else if(track->qt_last_a_pts != current_pts)
    3196             {
    3197                 sh->i_bps = length / (current_pts - track->qt_last_a_pts);
    3198                 track->fix_i_bps = 0;
    3199             }
    3200         }
    3201     }
    3202     else if (tc < mkv_d->skip_to_timecode)
    3203         use_this_block = 0;
    3204     else if (num == demuxer->video->id)
    3205     {
    3206         ds = demuxer->video;
    3207         if (mkv_d->v_skip_to_keyframe)
    3208         {
    3209             if (simpleblock)
    3210             {
    3211                 if (!(flags&0x80))   /*current frame isn't a keyframe*/
    3212                     use_this_block = 0;
    3213             }
    3214             else if (block_bref != 0 || block_fref != 0)
    3215                 use_this_block = 0;
    3216         }
    3217     }
    3218     else if (num == demuxer->sub->id)
    3219     {
    3220         ds = demuxer->sub;
    3221         if (track->subtitle_type != MATROSKA_SUBTYPE_VOBSUB)
    3222         {
    3223             if (!mkv_d->v_skip_to_keyframe)
    3224                 handle_subtitles (demuxer, track, block, length,
    3225                                   block_duration, tc);
    3226             use_this_block = 0;
    3227         }
    3228     }
    3229     else
    3230         use_this_block = 0;
    3231 
    3232     if (use_this_block)
    3233     {
    3234         mkv_d->last_pts = current_pts;
    3235         mkv_d->last_filepos = demuxer->filepos;
    3236 
    3237         for (i=0; i < laces; i++)
    3238         {
    3239             if (ds == demuxer->video && track->realmedia)
    3240                 handle_realvideo (demuxer, track, block, lace_size[i], block_bref);
    3241             else if (ds == demuxer->audio && track->realmedia)
    3242                 handle_realaudio (demuxer, track, block, lace_size[i], block_bref);
    3243             else if (ds == demuxer->video && track->reorder_timecodes)
    3244                 handle_video_bframes (demuxer, track, block, lace_size[i],
    3245                                       block_bref, block_fref);
    3246             else
    3247             {
    3248                 int modified, size = lace_size[i];
    3249                 demux_packet_t *dp;
    3250                 uint8_t *buffer;
    3251                 modified = demux_mkv_decode (track, block, &buffer, &size, 1);
    3252                 if (buffer)
     3472              int modified, size = lace_size[i];
     3473              demux_packet_t *dp;
     3474              uint8_t *buffer;
     3475              modified = demux_mkv_decode (track, block, &buffer, &size, 1);
     3476              if (buffer)
    32533477                {
    3254                     dp = new_demux_packet (size);
    3255                     memcpy (dp->buffer, buffer, size);
    3256                     if (modified)
    3257                         free (buffer);
    3258                     dp->flags = (block_bref == 0 && block_fref == 0) ? 0x10 : 0;
    3259                     /* If default_duration is 0, assume no pts value is known
    3260                      * for packets after the first one (rather than all pts
    3261                      * values being the same) */
    3262                     if (i == 0 || track->default_duration)
    3263                         dp->pts = mkv_d->last_pts + i * track->default_duration;
    3264                     ds_add_packet (ds, dp);
     3478                  dp = new_demux_packet (size);
     3479                  memcpy (dp->buffer, buffer, size);
     3480                  if (modified)
     3481                    free (buffer);
     3482                  dp->flags = (block_bref == 0 && block_fref == 0) ? 0x10 : 0;
     3483                  /* If default_duration is 0, assume no pts value is known
     3484                   * for packets after the first one (rather than all pts
     3485                   * values being the same) */
     3486                  if (i == 0 || track->default_duration)
     3487                  dp->pts = mkv_d->last_pts + i * track->default_duration;
     3488                  ds_add_packet (ds, dp);
    32653489                }
    32663490            }
    3267             block += lace_size[i];
    3268         }
    3269 
    3270         if (ds == demuxer->video)
    3271         {
    3272             mkv_d->v_skip_to_keyframe = 0;
    3273             mkv_d->skip_to_timecode = 0;
    3274         }
    3275         else if (ds == demuxer->audio)
    3276             mkv_d->a_skip_to_keyframe = 0;
    3277 
    3278         free(lace_size);
    3279         return 1;
    3280     }
    3281 
    3282     free(lace_size);
    3283     return 0;
     3491          block += lace_size[i];
     3492        }
     3493
     3494      if (ds == demuxer->video)
     3495        {
     3496          mkv_d->v_skip_to_keyframe = 0;
     3497          mkv_d->skip_to_timecode = 0;
     3498        }
     3499      else if (ds == demuxer->audio)
     3500        mkv_d->a_skip_to_keyframe = 0;
     3501
     3502      free(lace_size);
     3503      return 1;
     3504    }
     3505
     3506  free(lace_size);
     3507  return 0;
    32843508}
    32853509
    … …  
    32873511demux_mkv_fill_buffer (demuxer_t *demuxer, demux_stream_t *ds)
    32883512{
    3289     mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
    3290     stream_t *s = demuxer->stream;
    3291     uint64_t l;
    3292     int il, tmp;
    3293 
    3294     while (1)
    3295     {
    3296         while (mkv_d->cluster_size > 0)
    3297         {
    3298             uint64_t block_duration = 0,  block_length = 0;
    3299             int64_t block_bref = 0, block_fref = 0;
    3300             uint8_t *block = NULL;
    3301 
    3302             while (mkv_d->blockgroup_size > 0)
     3513  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
     3514  stream_t *s = demuxer->stream;
     3515  uint64_t l;
     3516  int il, tmp;
     3517
     3518  while (1)
     3519    {
     3520      while (mkv_d->cluster_size > 0)
     3521        {
     3522          uint64_t block_duration = 0,  block_length = 0;
     3523          int64_t block_bref = 0, block_fref = 0;
     3524          uint8_t *block = NULL;
     3525
     3526          while (mkv_d->blockgroup_size > 0)
    33033527            {
    3304                 switch (ebml_read_id (s, &il))
     3528              switch (ebml_read_id (s, &il))
    33053529                {
    33063530                case MATROSKA_ID_BLOCKDURATION:
    3307                     {
    3308                         block_duration = ebml_read_uint (s, &l);
    3309                         if (block_duration == EBML_UINT_INVALID)
    3310                             return 0;
    3311                         block_duration *= mkv_d->tc_scale / 1000000.0;
    3312                         break;
    3313                     }
     3531                  {
     3532                    block_duration = ebml_read_uint (s, &l);
     3533                    if (block_duration == EBML_UINT_INVALID)
     3534                      return 0;
     3535                    block_duration *= mkv_d->tc_scale / 1000000.0;
     3536                    break;
     3537                  }
    33143538
    33153539                case MATROSKA_ID_BLOCK:
     3540                  block_length = ebml_read_length (s, &tmp);
     3541                  free(block);
     3542                  block = malloc (block_length);
     3543                  demuxer->filepos = stream_tell (s);
     3544                  if (stream_read (s,block,block_length) != (int) block_length)
     3545                  {
     3546                    free(block);
     3547                    return 0;
     3548                  }
     3549                  l = tmp + block_length;
     3550                  break;
     3551
     3552                case MATROSKA_ID_REFERENCEBLOCK:
     3553                  {
     3554                    int64_t num = ebml_read_int (s, &l);
     3555                    if (num == EBML_INT_INVALID)
     3556                      return 0;
     3557                    if (num <= 0)
     3558                      block_bref = num;
     3559                    else
     3560                      block_fref = num;
     3561                    break;
     3562                  }
     3563
     3564                case EBML_ID_INVALID:
     3565                  return 0;
     3566
     3567                default:
     3568                  ebml_read_skip (s, &l);
     3569                  break;
     3570                }
     3571              mkv_d->blockgroup_size -= l + il;
     3572              mkv_d->cluster_size -= l + il;
     3573            }
     3574
     3575          if (block)
     3576            {
     3577              int res = handle_block (demuxer, block, block_length,
     3578                                      block_duration, block_bref, block_fref, 0);
     3579              free (block);
     3580              if (res < 0)
     3581                return 0;
     3582              if (res)
     3583                return 1;
     3584            }
     3585
     3586          if (mkv_d->cluster_size > 0)
     3587            {
     3588              switch (ebml_read_id (s, &il))
     3589                {
     3590                case MATROSKA_ID_CLUSTERTIMECODE:
     3591                  {
     3592                    uint64_t num = ebml_read_uint (s, &l);
     3593                    if (num == EBML_UINT_INVALID)
     3594                      return 0;
     3595                    if (!mkv_d->has_first_tc)
     3596                      {
     3597                        mkv_d->first_tc = num * mkv_d->tc_scale / 1000000.0;
     3598                        mkv_d->has_first_tc = 1;
     3599                      }
     3600                    mkv_d->cluster_tc = num * mkv_d->tc_scale;
     3601                    break;
     3602                  }
     3603
     3604                case MATROSKA_ID_BLOCKGROUP:
     3605                  mkv_d->blockgroup_size = ebml_read_length (s, &tmp);
     3606                  l = tmp;
     3607                  break;
     3608
     3609                case MATROSKA_ID_SIMPLEBLOCK:
     3610                  {
     3611                    int res;
    33163612                    block_length = ebml_read_length (s, &tmp);
    3317                     free(block);
    3318                     block = (uint8_t *) malloc (block_length);
     3613                    block = malloc (block_length);
    33193614                    demuxer->filepos = stream_tell (s);
    33203615                    if (stream_read (s,block,block_length) != (int) block_length)
    33213616                    {
    3322                         free(block);
    3323                         return 0;
     3617                      free(block);
     3618                      return 0;
    33243619                    }
    33253620                    l = tmp + block_length;
     3621                    res = handle_block (demuxer, block, block_length,
     3622                                        block_duration, block_bref, block_fref, 1);
     3623                    free (block);
     3624                    mkv_d->cluster_size -= l + il;
     3625                    if (res < 0)
     3626                      return 0;
     3627                    else if (res)
     3628                      return 1;
     3629                    else mkv_d->cluster_size += l + il;
    33263630                    break;
    3327 
    3328                 case MATROSKA_ID_REFERENCEBLOCK:
    3329                     {
    3330                         int64_t num = ebml_read_int (s, &l);
    3331                         if (num == EBML_INT_INVALID)
    3332                             return 0;
    3333                         if (num <= 0)
    3334                             block_bref = num;
    3335                         else
    3336                             block_fref = num;
    3337                         break;
    3338                     }
    3339 
     3631                  }
    33403632                case EBML_ID_INVALID:
    3341                     return 0;
     3633                  return 0;
    33423634
    33433635                default:
    3344                     ebml_read_skip (s, &l);
    3345                     break;
     3636                  ebml_read_skip (s, &l);
     3637                  break;
    33463638                }
    3347                 mkv_d->blockgroup_size -= l + il;
    3348                 mkv_d->cluster_size -= l + il;
     3639              mkv_d->cluster_size -= l + il;
    33493640            }
    3350 
    3351             if (block)
     3641        }
     3642
     3643      if (ebml_read_id (s, &il) != MATROSKA_ID_CLUSTER)
     3644        return 0;
     3645      add_cluster_position(mkv_d, stream_tell(s)-il);
     3646      mkv_d->cluster_size = ebml_read_length (s, NULL);
     3647    }
     3648
     3649  return 0;
     3650}
     3651
     3652static void
     3653demux_mkv_seek (demuxer_t *demuxer, float rel_seek_secs, float audio_delay, int flags)
     3654{
     3655  free_cached_dps (demuxer);
     3656  if (!(flags & 2))  /* time in secs */
     3657    {
     3658      mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
     3659      stream_t *s = demuxer->stream;
     3660      int64_t target_timecode = 0, diff, min_diff=0xFFFFFFFL;
     3661      int i;
     3662
     3663      if (!(flags & 1))  /* relative seek */
     3664        target_timecode = (int64_t) (mkv_d->last_pts * 1000.0);
     3665      target_timecode += (int64_t)(rel_seek_secs * 1000.0);
     3666      if (target_timecode < 0)
     3667        target_timecode = 0;
     3668
     3669      if (mkv_d->indexes == NULL)  /* no index was found */
     3670        {
     3671          uint64_t target_filepos, cluster_pos, max_pos;
     3672
     3673          target_filepos = (uint64_t) (target_timecode * mkv_d->last_filepos
     3674                                       / (mkv_d->last_pts * 1000.0));
     3675
     3676          max_pos = mkv_d->cluster_positions[mkv_d->num_cluster_pos-1];
     3677          if (target_filepos > max_pos)
    33523678            {
    3353                 int res = handle_block (demuxer, block, block_length,
    3354                                         block_duration, block_bref, block_fref, 0);
    3355                 free (block);
    3356                 if (res < 0)
    3357                     return 0;
    3358                 if (res)
    3359                     return 1;
    3360             }
    3361 
    3362             if (mkv_d->cluster_size > 0)
    3363             {
    3364                 switch (ebml_read_id (s, &il))
     3679              if ((off_t) max_pos > stream_tell (s))
     3680                stream_seek (s, max_pos);
     3681              else
     3682                stream_seek (s, stream_tell (s) + mkv_d->cluster_size);
     3683              /* parse all the clusters upto target_filepos */
     3684              while (!s->eof && stream_tell(s) < (off_t) target_filepos)
    33653685                {
    3366                 case MATROSKA_ID_CLUSTERTIMECODE:
    3367                     {
    3368                         uint64_t num = ebml_read_uint (s, &l);
    3369                         if (num == EBML_UINT_INVALID)
    3370                             return 0;
    3371                         if (!mkv_d->has_first_tc)
    3372                         {
    3373                             mkv_d->first_tc = num * mkv_d->tc_scale / 1000000.0;
    3374                             mkv_d->has_first_tc = 1;
    3375                         }
    3376                         mkv_d->cluster_tc = num * mkv_d->tc_scale;
    3377                         break;
    3378                     }
    3379 
    3380                 case MATROSKA_ID_BLOCKGROUP:
    3381                     mkv_d->blockgroup_size = ebml_read_length (s, &tmp);
    3382                     l = tmp;
    3383                     break;
    3384 
    3385                 case MATROSKA_ID_SIMPLEBLOCK:
    3386                     {
    3387                         int res;
    3388                         block_length = ebml_read_length (s, &tmp);
    3389                         block = (uint8_t *) malloc (block_length);
    3390                         demuxer->filepos = stream_tell (s);
    3391                         if (stream_read (s,block,block_length) != (int) block_length)
    3392                         {
    3393                             free(block);
    3394                             return 0;
    3395                         }
    3396                         l = tmp + block_length;
    3397                         res = handle_block (demuxer, block, block_length,
    3398                                             block_duration, block_bref, block_fref, 1);
    3399                         free (block);
    3400                         mkv_d->cluster_size -= l + il;
    3401                         if (res < 0)
    3402                             return 0;
    3403                         else if (res)
    3404                             return 1;
    3405                         else mkv_d->cluster_size += l + il;
    3406                         break;
    3407                     }
    3408                 case EBML_ID_INVALID:
    3409                     return 0;
    3410 
    3411                 default:
    3412                     ebml_read_skip (s, &l);
    3413                     break;
    3414                 }
    3415                 mkv_d->cluster_size -= l + il;
    3416             }
    3417         }
    3418 
    3419         if (ebml_read_id (s, &il) != MATROSKA_ID_CLUSTER)
    3420             return 0;
    3421         add_cluster_position(mkv_d, stream_tell(s)-il);
    3422         mkv_d->cluster_size = ebml_read_length (s, NULL);
    3423     }
    3424 
    3425     return 0;
    3426 }
    3427 
    3428 static void
    3429 demux_mkv_seek (demuxer_t *demuxer, float rel_seek_secs, /*float audio_delay, */int flags)
    3430 {
    3431     free_cached_dps (demuxer);
    3432     if (!(flags & 2))  /* time in secs */
    3433     {
    3434         mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
    3435         stream_t *s = demuxer->stream;
    3436         int64_t target_timecode = 0, diff, min_diff=0xFFFFFFFL;
    3437         int i;
    3438 
    3439         if (!(flags & 1))  /* relative seek */
    3440             target_timecode = (int64_t) (mkv_d->last_pts * 1000.0);
    3441         target_timecode += (int64_t)(rel_seek_secs * 1000.0);
    3442         if (target_timecode < 0)
    3443             target_timecode = 0;
    3444 
    3445         if (mkv_d->indexes == NULL)  /* no index was found */
    3446         {
    3447             uint64_t target_filepos, cluster_pos, max_pos;
    3448 
    3449             target_filepos = (uint64_t) (target_timecode * mkv_d->last_filepos
    3450                                          / (mkv_d->last_pts * 1000.0));
    3451 
    3452             max_pos = mkv_d->cluster_positions[mkv_d->num_cluster_pos-1];
    3453             if (target_filepos > max_pos)
    3454             {
    3455                 if ((off_t) max_pos > stream_tell (s))
    3456                     stream_seek (s, max_pos);
    3457                 else
    3458                     stream_seek (s, stream_tell (s) + mkv_d->cluster_size);
    3459                 /* parse all the clusters upto target_filepos */
    3460                 while (!s->eof && stream_tell(s) < (off_t) target_filepos)
    3461                 {
    3462                     switch (ebml_read_id (s, &i))
     3686                  switch (ebml_read_id (s, &i))
    34633687                    {
    34643688                    case MATROSKA_ID_CLUSTER:
    3465                         add_cluster_position(mkv_d, (uint64_t) stream_tell(s)-i);
    3466                         break;
     3689                      add_cluster_position(mkv_d, (uint64_t) stream_tell(s)-i);
     3690                      break;
    34673691
    34683692                    case MATROSKA_ID_CUES:
    3469                         demux_mkv_read_cues (demuxer);
    3470                         break;
     3693                      demux_mkv_read_cues (demuxer);
     3694                      break;
    34713695                    }
    3472                     ebml_read_skip (s, NULL);
     3696                  ebml_read_skip (s, NULL);
    34733697                }
    3474                 if (s->eof)
    3475                     stream_reset(s);
     3698              if (s->eof)
     3699                stream_reset(s);
    34763700            }
    34773701
    3478             if (mkv_d->indexes == NULL)
     3702          if (mkv_d->indexes == NULL)
    34793703            {
    3480                 cluster_pos = mkv_d->cluster_positions[0];
    3481                 /* Let's find the nearest cluster */
    3482                 for (i=0; i < mkv_d->num_cluster_pos; i++)
     3704              cluster_pos = mkv_d->cluster_positions[0];
     3705              /* Let's find the nearest cluster */
     3706              for (i=0; i < mkv_d->num_cluster_pos; i++)
    34833707                {
    3484                     diff = mkv_d->cluster_positions[i] - target_filepos;
    3485                     if (rel_seek_secs < 0 && diff < 0 && -diff < min_diff)
     3708                  diff = mkv_d->cluster_positions[i] - target_filepos;
     3709                  if (rel_seek_secs < 0 && diff < 0 && -diff < min_diff)
    34863710                    {
    3487                         cluster_pos = mkv_d->cluster_positions[i];
    3488                         min_diff = -diff;
     3711                      cluster_pos = mkv_d->cluster_positions[i];
     3712                      min_diff = -diff;
    34893713                    }
    3490                     else if (rel_seek_secs > 0
    3491                              && (diff < 0 ? -1 * diff : diff) < min_diff)
     3714                  else if (rel_seek_secs > 0
     3715                           && (diff < 0 ? -1 * diff : diff) < min_diff)
    34923716                    {
    3493                         cluster_pos = mkv_d->cluster_positions[i];
    3494                         min_diff = diff < 0 ? -1 * diff : diff;
     3717                      cluster_pos = mkv_d->cluster_positions[i];
     3718                      min_diff = diff < 0 ? -1 * diff : diff;
    34953719                    }
    34963720                }
    3497                 mkv_d->cluster_size = mkv_d->blockgroup_size = 0;
    3498                 stream_seek (s, cluster_pos);
     3721              mkv_d->cluster_size = mkv_d->blockgroup_size = 0;
     3722              stream_seek (s, cluster_pos);
    34993723            }
    35003724        }
    3501         else
    3502         {
    3503             mkv_index_t *index = NULL;
    3504 
    3505             /* let's find the entry in the indexes with the smallest */
    3506             /* difference to the wanted timecode. */
    3507             for (i=0; i < mkv_d->num_indexes; i++)
    3508                 if (mkv_d->indexes[i].tnum == demuxer->video->id)
    3509                 {
    3510                     diff = target_timecode + mkv_d->first_tc -
    3511                         (int64_t) mkv_d->indexes[i].timecode * mkv_d->tc_scale / 1000000.0;
    3512 
    3513                     if ((flags & 1 || target_timecode <= mkv_d->last_pts*1000)
    3514                         && diff >= 0 && diff < min_diff)
    3515                     {
    3516                         min_diff = diff;
    3517                         index = mkv_d->indexes + i;
    3518                     }
    3519                     else if (target_timecode > mkv_d->last_pts*1000
    3520                              && diff < 0 && -diff < min_diff)
    3521                     {
    3522                         min_diff = -diff;
    3523                         index = mkv_d->indexes + i;
    3524                     }
    3525                 }
    3526 
    3527             if (index)  /* We've found an entry. */
     3725      else
     3726        {
     3727          mkv_index_t *index = NULL;
     3728          int seek_id = (demuxer->video->id < 0) ? demuxer->audio->id : demuxer->video->id; 
     3729
     3730          /* let's find the entry in the indexes with the smallest */
     3731          /* difference to the wanted timecode. */
     3732          for (i=0; i < mkv_d->num_indexes; i++)
     3733            if (mkv_d->indexes[i].tnum == seek_id)
     3734              {
     3735                diff = target_timecode + mkv_d->first_tc -
     3736                       (int64_t) mkv_d->indexes[i].timecode * mkv_d->tc_scale / 1000000.0;
     3737
     3738                if ((flags & 1 || target_timecode <= mkv_d->last_pts*1000)
     3739                    && diff >= 0 && diff < min_diff)
     3740                  {
     3741                    min_diff = diff;
     3742                    index = mkv_d->indexes + i;
     3743                  }
     3744                else if (target_timecode > mkv_d->last_pts*1000
     3745                         && diff < 0 && -diff < min_diff)
     3746                  {
     3747                    min_diff = -diff;
     3748                    index = mkv_d->indexes + i;
     3749                  }
     3750              }
     3751
     3752          if (index)  /* We've found an entry. */
    35283753            {
    3529                 mkv_d->cluster_size = mkv_d->blockgroup_size = 0;
    3530                 stream_seek (s, index->filepos);
     3754              mkv_d->cluster_size = mkv_d->blockgroup_size = 0;
     3755              stream_seek (s, index->filepos);
    35313756            }
    35323757        }
    35333758
    3534         if (demuxer->video->id >= 0)
    3535             mkv_d->v_skip_to_keyframe = 1;
    3536         if (rel_seek_secs > 0.0)
    3537             mkv_d->skip_to_timecode = target_timecode;
    3538         mkv_d->a_skip_to_keyframe = 1;
    3539 
    3540         /* Clear subtitles. */
    3541         if (target_timecode <= mkv_d->last_pts * 1000)
    3542             clear_subtitles(demuxer, 0, 1);
    3543 
    3544         demux_mkv_fill_buffer(demuxer, NULL);
    3545     }
    3546     else if ((demuxer->movi_end <= 0) || !(flags & 1))
    3547         dprintf ("[mkv] seek unsupported flags\n");
    3548     else
    3549     {
    3550         mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
    3551         stream_t *s = demuxer->stream;
    3552         uint64_t target_filepos;
    3553         mkv_index_t *index = NULL;
    3554         int i;
    3555 
    3556         if (mkv_d->indexes == NULL)  /* no index was found */
     3759      if (demuxer->video->id >= 0)
     3760        mkv_d->v_skip_to_keyframe = 1;
     3761      if (rel_seek_secs > 0.0)
     3762        mkv_d->skip_to_timecode = target_timecode;
     3763      mkv_d->a_skip_to_keyframe = 1;
     3764
     3765      /* Clear subtitles. */
     3766      if (target_timecode <= mkv_d->last_pts * 1000)
     3767        clear_subtitles(demuxer, 0, 1);
     3768
     3769      demux_mkv_fill_buffer(demuxer, NULL);
     3770    }
     3771  else if ((demuxer->movi_end <= 0) || !(flags & 1))
     3772    dprintf("[mkv] seek unsupported flags\n");
     3773  else
     3774    {
     3775      mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
     3776      stream_t *s = demuxer->stream;
     3777      uint64_t target_filepos;
     3778      mkv_index_t *index = NULL;
     3779      int i;
     3780
     3781      if (mkv_d->indexes == NULL)  /* no index was found */
    35573782        {                       /* I'm lazy... */
    3558             dprintf ("[mkv] seek unsupported flags\n");
    3559             return;
    3560         }
    3561 
    3562         target_filepos = (uint64_t)(demuxer->movi_end * rel_seek_secs);
    3563         for (i=0; i < mkv_d->num_indexes; i++)
    3564             if (mkv_d->indexes[i].tnum == demuxer->video->id)
    3565                 if ((index == NULL) ||
    3566                     ((mkv_d->indexes[i].filepos >= target_filepos) &&
    3567                      ((index->filepos < target_filepos) ||
    3568                       (mkv_d->indexes[i].filepos < index->filepos))))
    3569                     index = &mkv_d->indexes[i];
    3570 
    3571         if (!index)
    3572             return;
    3573 
    3574         mkv_d->cluster_size = mkv_d->blockgroup_size = 0;
    3575         stream_seek (s, index->filepos);
    3576 
    3577         if (demuxer->video->id >= 0)
    3578             mkv_d->v_skip_to_keyframe = 1;
    3579         mkv_d->skip_to_timecode = index->timecode;
    3580         mkv_d->a_skip_to_keyframe = 1;
    3581 
    3582         /* Clear subtitles. */
    3583         if (index->timecode <= mkv_d->last_pts * 1000)
    3584             clear_subtitles(demuxer, 0, 1);
    3585 
    3586         demux_mkv_fill_buffer(demuxer, NULL);
     3783          dprintf("[mkv] seek unsupported flags\n");
     3784          return;
     3785        }
     3786
     3787      target_filepos = (uint64_t)(demuxer->movi_end * rel_seek_secs);
     3788      for (i=0; i < mkv_d->num_indexes; i++)
     3789        if (mkv_d->indexes[i].tnum == demuxer->video->id)
     3790          if ((index == NULL) ||
     3791              ((mkv_d->indexes[i].filepos >= target_filepos) &&
     3792               ((index->filepos < target_filepos) ||
     3793                (mkv_d->indexes[i].filepos < index->filepos))))
     3794            index = &mkv_d->indexes[i];
     3795
     3796      if (!index)
     3797        return;
     3798
     3799      mkv_d->cluster_size = mkv_d->blockgroup_size = 0;
     3800      stream_seek (s, index->filepos);
     3801
     3802      if (demuxer->video->id >= 0)
     3803        mkv_d->v_skip_to_keyframe = 1;
     3804      mkv_d->skip_to_timecode = index->timecode;
     3805      mkv_d->a_skip_to_keyframe = 1;
     3806
     3807      /* Clear subtitles. */
     3808      if (index->timecode <= mkv_d->last_pts * 1000)
     3809        clear_subtitles(demuxer, 0, 1);
     3810
     3811      demux_mkv_fill_buffer(demuxer, NULL);
    35873812    }
    35883813}
    … …  
    35913816demux_mkv_control (demuxer_t *demuxer, int cmd, void *arg)
    35923817{
    3593     mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
    3594 
    3595     switch (cmd)
     3818  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
     3819 
     3820  switch (cmd)
    35963821    {
    35973822    case DEMUXER_CTRL_GET_TIME_LENGTH:
    3598         if (mkv_d->duration == 0)
     3823      if (mkv_d->duration == 0)
     3824        return DEMUXER_CTRL_DONTKNOW;
     3825
     3826      *((double *)arg) = (double)mkv_d->duration;
     3827      return DEMUXER_CTRL_OK;
     3828
     3829    case DEMUXER_CTRL_GET_PERCENT_POS:
     3830      if (mkv_d->duration == 0)
     3831        {
    35993832            return DEMUXER_CTRL_DONTKNOW;
    3600 
    3601         *((double *)arg) = (double)mkv_d->duration;
    3602         return DEMUXER_CTRL_OK;
    3603 
    3604     case DEMUXER_CTRL_GET_PERCENT_POS:
    3605         if (mkv_d->duration == 0)
    3606         {
    3607             return DEMUXER_CTRL_DONTKNOW;
    3608         }
    3609 
    3610         *((int *) arg) = (int) (100 * mkv_d->last_pts / mkv_d->duration);
    3611         return DEMUXER_CTRL_OK;
     3833        }
     3834
     3835      *((int *) arg) = (int) (100 * mkv_d->last_pts / mkv_d->duration);
     3836      return DEMUXER_CTRL_OK;
    36123837
    36133838    case DEMUXER_CTRL_SWITCH_AUDIO:
    3614         if (demuxer->audio && demuxer->audio->sh) {
    3615             int i;
    3616             demux_stream_t *d_audio = demuxer->audio;
    3617             int idx = d_audio->id - 1; // track ids are 1 based
    3618             mkv_track_t *otrack = mkv_d->tracks[idx];
    3619             mkv_track_t *track = 0;
    3620             if (*((int*)arg) < 0)
    3621                 for(i = 0; i < mkv_d->last_aid; i++) {
    3622                     if(mkv_d->audio_tracks[i] == d_audio->id) {
    3623                         idx = mkv_d->audio_tracks[(i+1) % mkv_d->last_aid] - 1;
    3624                         track = mkv_d->tracks[idx];
    3625                         if(! track)
    3626                             continue;
    3627                         if (track->type == MATROSKA_TRACK_AUDIO) break;
    3628                     }
    3629                 }
    3630             else {
    3631                 track = demux_mkv_find_track_by_num (mkv_d, *((int*)arg), MATROSKA_TRACK_AUDIO);
    3632                 if (track == NULL)
    3633                     track = otrack;
    3634             }
    3635             if (track != otrack) {
    3636                 d_audio->id = track->tnum;
    3637                 ds_free_packs(d_audio);
    3638             }
    3639         }
    3640         *((int*)arg) = demuxer->audio->id;
    3641         return DEMUXER_CTRL_OK;
     3839      if (demuxer->audio && demuxer->audio->sh) {
     3840        sh_audio_t *sh = demuxer->a_streams[demuxer->audio->id];
     3841        int aid = *(int*)arg;
     3842        if (aid < 0)
     3843          aid = (sh->aid + 1) % mkv_d->last_aid;
     3844        if (aid != sh->aid) {
     3845          mkv_track_t *track = demux_mkv_find_track_by_num (mkv_d, aid, MATROSKA_TRACK_AUDIO);
     3846          if (track) {
     3847            demuxer->audio->id = track->tnum;
     3848            sh = demuxer->a_streams[demuxer->audio->id];
     3849            ds_free_packs(demuxer->audio);
     3850          }
     3851        }
     3852        *(int*)arg = sh->aid;
     3853      } else
     3854        *(int*)arg = -2;
     3855      return DEMUXER_CTRL_OK;
    36423856
    36433857    default:
    3644         return DEMUXER_CTRL_NOTIMPL;
    3645     }
    3646 }
    3647 
    3648 /** \brief Return the number of subtitle tracks in the file.
    3649 
    3650 \param demuxer The demuxer for which the number of subtitle tracks
    3651 should be returned.
    3652 */
    3653 int
    3654 demux_mkv_num_subs (demuxer_t *demuxer)
    3655 {
    3656     mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
    3657     int i, num;
    3658 
    3659     num = 0;
    3660     for (i = 0; i < mkv_d->num_tracks; i++)
    3661         if ((mkv_d->tracks[i]->type == MATROSKA_TRACK_SUBTITLE) &&
    3662             (mkv_d->tracks[i]->subtitle_type != MATROSKA_SUBTYPE_UNKNOWN))
    3663             num++;
    3664 
    3665     return num;
     3858      return DEMUXER_CTRL_NOTIMPL;
     3859    }
    36663860}
    36673861
    36683862/** \brief Change the current subtitle track and return its ID.
    36693863
    3670 Changes the current subtitle track. If the new subtitle track is a
    3671 VobSub track then the SPU decoder will be re-initialized.
    3672 
    3673 \param demuxer The demuxer whose subtitle track will be changed.
    3674 \param new_num The number of the new subtitle track. The number must be
    3675 between 0 and demux_mkv_num_subs - 1.
    3676 
    3677 \returns The Matroska track number of the newly selected track.
     3864  Changes the current subtitle track. If the new subtitle track is a
     3865  VobSub track then the SPU decoder will be re-initialized.
     3866
     3867  \param demuxer The demuxer whose subtitle track will be changed.
     3868  \param new_num The number of the new subtitle track. The number must be
     3869  between 0 and demux_mkv_num_subs - 1.
     3870
     3871  \returns The Matroska track number of the newly selected track.
    36783872*/
    36793873int
    36803874demux_mkv_change_subs (demuxer_t *demuxer, int new_num)
    36813875{
    3682     mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
    3683     mkv_track_t *track;
    3684     int i, num;
    3685 
    3686     num = 0;
    3687     track = NULL;
    3688     for (i = 0; i < mkv_d->num_tracks; i++)
    3689     {
    3690         if ((mkv_d->tracks[i]->type == MATROSKA_TRACK_SUBTITLE) &&
    3691             (mkv_d->tracks[i]->subtitle_type != MATROSKA_SUBTYPE_UNKNOWN))
    3692             num++;
    3693         if (num == (new_num + 1))
    3694         {
    3695             track = mkv_d->tracks[i];
    3696             break;
    3697         }
    3698     }
    3699     if (track == NULL)
    3700         return -1;
    3701 
    3702     if (demuxer->sub->sh == NULL)
    3703         demuxer->sub->sh = malloc(sizeof(mkv_sh_sub_t));
    3704     if (demuxer->sub->sh != NULL)
    3705         memcpy(demuxer->sub->sh, &track->sh_sub, sizeof(mkv_sh_sub_t));
    3706 
    3707     return track->tnum;
     3876  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
     3877  mkv_track_t *track;
     3878  int i, num;
     3879
     3880  num = 0;
     3881  track = NULL;
     3882  for (i = 0; i < mkv_d->num_tracks; i++)
     3883    {
     3884      if ((mkv_d->tracks[i]->type == MATROSKA_TRACK_SUBTITLE) &&
     3885          (mkv_d->tracks[i]->subtitle_type != MATROSKA_SUBTYPE_UNKNOWN))
     3886        num++;
     3887      if (num == (new_num + 1))
     3888        {
     3889          track = mkv_d->tracks[i];
     3890          break;
     3891        }
     3892    }
     3893  if (track == NULL)
     3894    return -1;
     3895
     3896  if (demuxer->sub->sh == NULL)
     3897    demuxer->sub->sh = malloc(sizeof(sh_sub_t));
     3898  if (demuxer->sub->sh != NULL)
     3899    memcpy(demuxer->sub->sh, &track->sh_sub, sizeof(sh_sub_t));
     3900
     3901  return track->tnum;
    37083902}
    37093903
    37103904/** \brief Get the language code for a subtitle track.
    37113905
    3712 Retrieves the language code for a subtitle track if it is known.
    3713 If the language code is "und" then do not copy it ("und" = "undefined").
    3714 
    3715 \param demuxer The demuxer to work on
    3716 \param track_num The n'th subtitle track to get the language from
    3717 \param lang Store the language here
    3718 \param maxlen The maximum number of characters to copy into lang
     3906  Retrieves the language code for a subtitle track if it is known.
     3907  If the language code is "und" then do not copy it ("und" = "undefined").
     3908
     3909  \param demuxer The demuxer to work on
     3910  \param track_num The n'th subtitle track to get the language from
     3911  \param lang Store the language here
     3912  \param maxlen The maximum number of characters to copy into lang
    37193913*/
    37203914void
    … …  
    37223916                       int maxlen)
    37233917{
    3724     mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
    3725     mkv_track_t *track = demux_mkv_find_track_by_num (mkv_d, track_num, MATROSKA_TRACK_SUBTITLE);
    3726     if (track->language && strcmp(track->language, "und"))
    3727         strlcpy(lang, track->language, maxlen);
     3918  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
     3919  mkv_track_t *track = demux_mkv_find_track_by_num (mkv_d, track_num, MATROSKA_TRACK_SUBTITLE);
     3920  if (track->language && strcmp(track->language, "und"))
     3921    strlcpy(lang, track->language, maxlen);
    37283922}
    37293923
    37303924/** \brief Get the language code for an audio track.
    37313925
    3732 Retrieves the language code for an audio track if it is known.
    3733 If the language code is "und" then do not copy it ("und" = "undefined").
    3734 
    3735 \param demuxer The demuxer to work on
    3736 \param track_num The n'th audio track to get the language from
    3737 \param lang Store the language here
    3738 \param maxlen The maximum number of characters to copy into lang
     3926  Retrieves the language code for an audio track if it is known.
     3927  If the language code is "und" then do not copy it ("und" = "undefined").
     3928
     3929  \param demuxer The demuxer to work on
     3930  \param track_num The n'th audio track to get the language from
     3931  \param lang Store the language here
     3932  \param maxlen The maximum number of characters to copy into lang
    37393933*/
    37403934void
    37413935demux_mkv_get_audio_lang(demuxer_t *demuxer, int track_num, char *lang,
    3742                          int maxlen)
    3743 {
    3744     mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
    3745     mkv_track_t *track = demux_mkv_find_track_by_num (mkv_d, track_num, MATROSKA_TRACK_AUDIO);
    3746     if (track->language && strcmp(track->language, "und"))
    3747         strlcpy(lang, track->language, maxlen);
     3936                       int maxlen)
     3937{
     3938  mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
     3939  mkv_track_t *track = demux_mkv_find_track_by_num (mkv_d, track_num, MATROSKA_TRACK_AUDIO);
     3940  if (track->language && strcmp(track->language, "und"))
     3941    strlcpy(lang, track->language, maxlen);
    37483942}
    37493943
    37503944
    37513945demuxer_desc_t demuxer_desc_matroska = {
    3752     "Matroska demuxer",
    3753     "mkv",
    3754     "Matroska",
    3755     "Aurelien Jacobs",
    3756     "based on gstreamer demuxer by Ronald Bultje and demux_mkv.cpp by Moritz Bunkus",
    3757     DEMUXER_TYPE_MATROSKA,
    3758     1, // safe autodetect
    3759     demux_mkv_open,
    3760     demux_mkv_fill_buffer,
    3761     NULL,
    3762     demux_close_mkv,
    3763     demux_mkv_seek,
    3764     demux_mkv_control
     3946  "Matroska demuxer",
     3947  "mkv",
     3948  "Matroska",
     3949  "Aurelien Jacobs",
     3950  "based on gstreamer demuxer by Ronald Bultje and demux_mkv.cpp by Moritz Bunkus",
     3951  DEMUXER_TYPE_MATROSKA,
     3952  1, // safe autodetect
     3953  demux_mkv_open,
     3954  demux_mkv_fill_buffer,
     3955  NULL,
     3956  demux_close_mkv,
     3957  demux_mkv_seek,
     3958  demux_mkv_control
    37653959};

  • TabularUnified trunk/libmpdemux/demux_mov.c

    r181 r263  
    3131#include "stheader.h"
    3232
     33#include "subreader.h"
     34
     35extern subtitle* vo_sub;
     36int vo_osd_changed(int new_value);
     37#define OSDTYPE_OSD 1
     38#define OSDTYPE_SUBTITLE 2
     39#define OSDTYPE_PROGBAR 3
     40#define OSDTYPE_SPU 4
     41
    3342#include "bswap.h"
    3443
    … …  
    5362
    5463#define BE_16(x) (((unsigned char *)(x))[0] <<  8 | \
    55                   ((unsigned char *)(x))[1])
     64    ((unsigned char *)(x))[1])
    5665#define BE_32(x) (((unsigned char *)(x))[0] << 24 | \
    57                   ((unsigned char *)(x))[1] << 16 | \
    58                   ((unsigned char *)(x))[2] <<  8 | \
    59                   ((unsigned char *)(x))[3])
     66    ((unsigned char *)(x))[1] << 16 | \
     67    ((unsigned char *)(x))[2] <<  8 | \
     68    ((unsigned char *)(x))[3])
    6069
    6170#define char2short(x,y) BE_16(&(x)[(y)])
    … …  
    164173    if (trak->chunks_size <= 0)
    165174    {
    166         dprintf(MSGT_DEMUX,  "No chunk offset table, trying to build one!\n");
    167 
    168         trak->chunks_size = trak->samples_size; /* XXX: FIXME ! */
    169         trak->chunks = realloc(trak->chunks, sizeof(mov_chunk_t)*trak->chunks_size);
    170 
    171         for (i=0; i < trak->chunks_size; i++)
    172             trak->chunks[i].pos = -1;
     175        dprintf(MSGT_DEMUX,  "No chunk offset table, trying to build one!\n");
     176
     177        trak->chunks_size = trak->samples_size; /* XXX: FIXME ! */
     178        trak->chunks = realloc(trak->chunks, sizeof(mov_chunk_t)*trak->chunks_size);
     179
     180        for (i=0; i < trak->chunks_size; i++)
     181            trak->chunks[i].pos = -1;
    173182    }
    174183#endif
    … …  
    180189    i=trak->chunkmap_size;
    181190    while(i>0){
    182         --i;
    183         for(j=trak->chunkmap[i].first;j<last;j++){
    184             trak->chunks[j].desc=trak->chunkmap[i].sdid;
    185             trak->chunks[j].size=trak->chunkmap[i].spc;
    186         }
    187         last=trak->chunkmap[i].first;
     191        --i;
     192        for(j=trak->chunkmap[i].first;j<last;j++){
     193            trak->chunks[j].desc=trak->chunkmap[i].sdid;
     194            trak->chunks[j].size=trak->chunkmap[i].spc;
     195        }
     196        last=trak->chunkmap[i].first;
    188197    }
    189198
    … …  
    191200    for (i=0; i < trak->chunks_size; i++)
    192201    {
    193         /* fixup position */
    194         if (trak->chunks[i].pos == -1)
    195             if (i > 0)
    196                 trak->chunks[i].pos = trak->chunks[i-1].pos + trak->chunks[i-1].size;
    197             else
    198                 trak->chunks[i].pos = 0; /* FIXME: set initial pos */
     202        /* fixup position */
     203        if (trak->chunks[i].pos == -1)
     204            if (i > 0)
     205                trak->chunks[i].pos = trak->chunks[i-1].pos + trak->chunks[i-1].size;
     206            else
     207                trak->chunks[i].pos = 0; /* FIXME: set initial pos */
    199208#endif
    200209
    201     // calc pts of chunks:
    202     s=0;
    203     for(j=0;j<trak->chunks_size;j++){
    204         trak->chunks[j].sample=s;
    205         s+=trak->chunks[j].size;
     210        // calc pts of chunks:
     211        s=0;
     212        for(j=0;j<trak->chunks_size;j++){
     213            trak->chunks[j].sample=s;
     214            s+=trak->chunks[j].size;
     215        }
     216        i = 0;
     217        for (j = 0; j < trak->durmap_size; j++)
     218            i += trak->durmap[j].num;
     219        if (i != s) {
     220            dprintf("MOV: durmap and chunkmap sample count differ (%i vs %i)\n", i, s);
     221            if (i > s) s = i;
     222        }
     223
     224        // workaround for fixed-size video frames (dv and uncompressed)
     225        if(!trak->samples_size && trak->type!=MOV_TRAK_AUDIO){
     226            trak->samples_size=s;
     227            trak->samples=calloc(s, sizeof(mov_sample_t));
     228            for(i=0;i<s;i++)
     229                trak->samples[i].size=trak->samplesize;
     230            trak->samplesize=0;
     231        }
     232
     233        if(!trak->samples_size){
     234            // constant sampesize
     235            if(trak->durmap_size==1 || (trak->durmap_size==2 && trak->durmap[1].num==1)){
     236                trak->duration=trak->durmap[0].dur;
     237            } else dprintf("*** constant samplesize & variable duration not yet supported! ***\nContact the author if you have such sample file!\n");
     238            return;
     239        }
     240
     241        if (trak->samples_size < s) {
     242            dprintf("MOV: durmap or chunkmap bigger than sample count (%i vs %i)\n",
     243                    s, trak->samples_size);
     244            trak->samples_size = s;
     245            trak->samples = realloc_struct(trak->samples, s, sizeof(mov_sample_t));
     246        }
     247
     248        // calc pts:
     249        s=0;
     250        for(j=0;j<trak->durmap_size;j++){
     251            for(i=0;i<trak->durmap[j].num;i++){
     252                trak->samples[s].pts=pts;
     253                ++s;
     254                pts+=trak->durmap[j].dur;
     255            }
     256        }
     257
     258        // calc sample offsets
     259        s=0;
     260        for(j=0;j<trak->chunks_size;j++){
     261            off_t pos=trak->chunks[j].pos;
     262            for(i=0;i<trak->chunks[j].size;i++){
     263                trak->samples[s].pos=pos;
     264                dprintf( "Sample %5d: pts=%8d  off=0x%08X  size=%d\n",s,
     265                        trak->samples[s].pts,
     266                        (int)trak->samples[s].pos,
     267                        trak->samples[s].size);
     268                pos+=trak->samples[s].size;
     269                ++s;
     270            }
     271        }
     272
     273        // precalc editlist entries
     274        if(trak->editlist_size>0){
     275            int frame=0;
     276            int e_pts=0;
     277            for(i=0;i<trak->editlist_size;i++){
     278                mov_editlist_t* el=&trak->editlist[i];
     279                int sample=0;
     280                int pts=el->pos;
     281                el->start_frame=frame;
     282                if(pts<0){
     283                    // skip!
     284                    el->frames=0; continue;
     285                }
     286                // find start sample
     287                for(;sample<trak->samples_size;sample++){
     288                    if(pts<=trak->samples[sample].pts) break;
     289                }
     290                el->start_sample=sample;
     291                el->pts_offset=((long long)e_pts*(long long)trak->timescale)/(long long)timescale-trak->samples[sample].pts;
     292                pts+=((long long)el->dur*(long long)trak->timescale)/(long long)timescale;
     293                e_pts+=el->dur;
     294                // find end sample
     295                for(;sample<trak->samples_size;sample++){
     296                    if(pts<trak->samples[sample].pts) break;
     297                }
     298                el->frames=sample-el->start_sample;
     299                frame+=el->frames;
     300                dprintf("EL#%d: pts=%d  1st_sample=%d  frames=%d (%5.3fs)  pts_offs=%d\n",i,
     301                        el->pos,el->start_sample, el->frames,
     302                        (float)(el->dur)/(float)timescale, el->pts_offset);
     303            }
     304        }
    206305    }
    207     i = 0;
    208     for (j = 0; j < trak->durmap_size; j++)
    209       i += trak->durmap[j].num;
    210     if (i != s) {
    211       dprintf(
    212              "MOV: durmap and chunkmap sample count differ (%i vs %i)\n", i, s);
    213       if (i > s) s = i;
     306
     307#define MOV_MAX_TRACKS 256
     308#define MOV_MAX_SUBLEN 1024
     309
     310    typedef struct {
     311        off_t moov_start;
     312        off_t moov_end;
     313        off_t mdat_start;
     314        off_t mdat_end;
     315        int track_db;
     316        mov_track_t* tracks[MOV_MAX_TRACKS];
     317        int timescale; // movie timescale
     318        int duration;  // movie duration (in movie timescale units)
     319        subtitle subs;
     320        char subtext[MOV_MAX_SUBLEN + 1];
     321        int current_sub;
     322    } mov_priv_t;
     323
     324#define MOV_FOURCC(a,b,c,d) ((a<<24)|(b<<16)|(c<<8)|(d))
     325
     326    static int mov_check_file(demuxer_t* demuxer){
     327        int flags=0;
     328        int no=0;
     329        mov_priv_t* priv=malloc(sizeof(mov_priv_t));
     330
     331        dprintf("Checking for MOV\n");
     332
     333        memset(priv,0,sizeof(mov_priv_t));
     334        priv->current_sub = -1;
     335
     336        while(1){
     337            int i;
     338            int skipped=8;
     339            off_t len=stream_read_dword(demuxer->stream);
     340            unsigned int id=stream_read_dword(demuxer->stream);
     341            if(stream_eof(demuxer->stream)) break; // EOF
     342            if (len == 1) /* real size is 64bits - cjb */
     343            {
     344#ifndef _LARGEFILE_SOURCE
     345                if (stream_read_dword(demuxer->stream) != 0)
     346                    dprintf( "64bit file, but you've compiled MPlayer without LARGEFILE support!\n");
     347                len = stream_read_dword(demuxer->stream);
     348#else
     349                len = stream_read_qword(demuxer->stream);
     350#endif
     351                skipped += 8;
     352            }
     353#if 0
     354            else if (len == 0) /* deleted chunk */
     355            {
     356                /* XXX: CJB! is this right? - alex */
     357                goto skip_chunk;
     358            }
     359#endif
     360            else if(len<8) break; // invalid chunk
     361
     362            switch(id){
     363            case MOV_FOURCC('f','t','y','p'): {
     364                unsigned int tmp;
     365                // File Type Box (ftyp):
     366                // char[4]  major_brand    (eg. 'isom')
     367                // int      minor_version          (eg. 0x00000000)
     368                // char[4]  compatible_brands[]  (eg. 'mp41')
     369                // compatible_brands list spans to the end of box
     370#if 1
     371                tmp = stream_read_dword(demuxer->stream);
     372                switch(tmp) {
     373                case MOV_FOURCC('i','s','o','m'):
     374                    dprintf("ISO: File Type Major Brand: ISO Base Media\n");
     375                    break;
     376                case MOV_FOURCC('m','p','4','1'):
     377                    dprintf("ISO: File Type Major Brand: ISO/IEC 14496-1 (MPEG-4 system) v1\n");
     378                    break;
     379                case MOV_FOURCC('m','p','4','2'):
     380                    dprintf("ISO: File Type Major Brand: ISO/IEC 14496-1 (MPEG-4 system) v2\n");
     381                    break;
     382                case MOV_FOURCC('M','4','A',' '):
     383                    dprintf("ISO: File Type Major Brand: Apple iTunes AAC-LC Audio\n");
     384                    break;
     385                case MOV_FOURCC('M','4','P',' '):
     386                    dprintf("ISO: File Type Major Brand: Apple iTunes AAC-LC Protected Audio\n");
     387                    break;
     388                case MOV_FOURCC('q','t',' ',' '):
     389                    dprintf("ISO: File Type Major Brand: Original QuickTime\n");
     390                    break;
     391                case MOV_FOURCC('3','g','p','1'):
     392                    dprintf("ISO: File Type Major Brand: 3GPP Profile 1\n");
     393                    break;
     394                case MOV_FOURCC('3','g','p','2'):
     395                case MOV_FOURCC('3','g','2','a'):
     396                    dprintf("ISO: File Type Major Brand: 3GPP Profile 2\n");
     397                    break;
     398                case MOV_FOURCC('3','g','p','3'):
     399                    dprintf("ISO: File Type Major Brand: 3GPP Profile 3\n");
     400                    break;
     401                case MOV_FOURCC('3','g','p','4'):
     402                    dprintf("ISO: File Type Major Brand: 3GPP Profile 4\n");
     403                    break;
     404                case MOV_FOURCC('3','g','p','5'):
     405                    dprintf("ISO: File Type Major Brand: 3GPP Profile 5\n");
     406                    break;
     407                case MOV_FOURCC('m','m','p','4'):
     408                    dprintf("ISO: File Type Major Brand: Mobile ISO/IEC 14496-1 (MPEG-4 system)\n");
     409                    break;
     410                default:
     411                    tmp = be2me_32(tmp);
     412                    dprintf("ISO: Unknown File Type Major Brand: %.4s\n",(char *)&tmp);
     413                }
     414                dprintf("ISO: File Type Minor Version: %d\n",
     415                        stream_read_dword(demuxer->stream));
     416                skipped += 8;
     417                // List all compatible brands
     418                for(i = 0; i < ((len-16)/4); i++) {
     419                    tmp = be2me_32(stream_read_dword(demuxer->stream));
     420                    dprintf("ISO: File Type Compatible Brand #%d: %.4s\n",i,(char *)&tmp);
     421                    skipped += 4;
     422                }
     423#endif
     424            } break;
     425            case MOV_FOURCC('m','o','o','v'):
     426                //      case MOV_FOURCC('c','m','o','v'):
     427                dprintf("MOV: Movie header found!\n");
     428                priv->moov_start=(off_t)stream_tell(demuxer->stream);
     429                priv->moov_end=(off_t)priv->moov_start+len-skipped;
     430                dprintf("MOV: Movie header: start: %"PRIx64" end: %"PRIx64"\n",
     431                        (int64_t)priv->moov_start, (int64_t)priv->moov_end);
     432                skipped+=8;
     433                i = stream_read_dword(demuxer->stream)-8;
     434                if(stream_read_dword(demuxer->stream)==MOV_FOURCC('r','m','r','a')){
     435                    int ref=0;
     436                    skipped+=i;
     437                    dprintf("MOV: Reference Media file!!!\n");
     438                    //set demuxer type to playlist ...
     439                    demuxer->type=DEMUXER_TYPE_PLAYLIST;
     440                    while(i>0){
     441                        int len=stream_read_dword(demuxer->stream)-8;
     442                        int fcc=stream_read_dword(demuxer->stream);
     443                        if(len<0) break; // EOF!?
     444                        i-=8;
     445                        //                printf("i=%d  len=%d\n",i,len);
     446                        switch(fcc){
     447                        case MOV_FOURCC('r','m','d','a'):
     448                            continue;
     449                        case MOV_FOURCC('r','d','r','f'): {
     450                            int tmp=stream_read_dword(demuxer->stream);
     451                            int type=stream_read_dword_le(demuxer->stream);
     452                            int slen=stream_read_dword(demuxer->stream);
     453                            //char* s=malloc(slen+1);
     454                            //stream_read(demuxer->stream,s,slen);
     455
     456                            //FIXME: also store type & data_rate ?
     457                            ds_read_packet(demuxer->video,
     458                                           demuxer->stream,
     459                                           slen,
     460                                           0,
     461                                           stream_tell(demuxer->stream),
     462                                           0 // no flags
     463                                          );
     464                            flags|=4;
     465                            dprintf("Added reference to playlist\n");
     466                            //s[slen]=0;
     467                            //dprintf("REF: [%.4s] %s\n",&type,s);
     468                            len-=12+slen;i-=12+slen; break;
     469                        }
     470                        case MOV_FOURCC('r','m','d','r'): {
     471                            int flags=stream_read_dword(demuxer->stream);
     472                            int rate=stream_read_dword(demuxer->stream);
     473                            dprintf("  min. data rate: %d bits/sec\n",rate);
     474                            len-=8; i-=8; break;
     475                        }
     476                        case MOV_FOURCC('r','m','q','u'): {
     477                            int q=stream_read_dword(demuxer->stream);
     478                            dprintf("  quality index: %d\n",q);
     479                            len-=4; i-=4; break;
     480                        }
     481                        }
     482                        i-=len;stream_skip(demuxer->stream,len);
     483                    }
     484                }
     485                flags|=1;
     486                break;
     487            case MOV_FOURCC('w','i','d','e'):
     488                dprintf("MOV: 'WIDE' chunk found!\n");
     489                if(flags&2) break;
     490            case MOV_FOURCC('m','d','a','t'):
     491                dprintf("MOV: Movie DATA found!\n");
     492                priv->mdat_start=stream_tell(demuxer->stream);
     493                priv->mdat_end=priv->mdat_start+len-skipped;
     494                dprintf("MOV: Movie data: start: %"PRIx64" end: %"PRIx64"\n",
     495                        (int64_t)priv->mdat_start, (int64_t)priv->mdat_end);
     496                flags|=2;
     497                if(flags==3){
     498                    // if we're over the headers, then we can stop parsing here!
     499                    demuxer->priv=priv;
     500                    return DEMUXER_TYPE_MOV;
     501                }
     502                break;
     503            case MOV_FOURCC('f','r','e','e'):
     504            case MOV_FOURCC('s','k','i','p'):
     505            case MOV_FOURCC('j','u','n','k'):
     506                dprintf("MOV: free space (len: %"PRId64")\n", (int64_t)len);
     507                /* unused, if you edit a mov, you can use space provided by free atoms (redefining it) */
     508                break;
     509            case MOV_FOURCC('p','n','o','t'):
     510            case MOV_FOURCC('P','I','C','T'):
     511                /* dunno what, but we shoudl ignore it */
     512                break;
     513            default:
     514                if(no==0){ free(priv); return 0;} // first chunk is bad!
     515                id = be2me_32(id);
     516                dprintf("MOV: unknown chunk: %.4s %d\n",(char *)&id,(int)len);
     517            }
     518        skip_chunk:
     519            if(!stream_skip(demuxer->stream,len-skipped)) break;
     520            ++no;
     521        }
     522
     523        if(flags==3){
     524            demuxer->priv=priv;
     525            return DEMUXER_TYPE_MOV;
     526        }
     527        free(priv);
     528
     529        if ((flags==5) || (flags==7)) // reference & header sent
     530            return DEMUXER_TYPE_PLAYLIST;
     531
     532        if(flags==1)
     533            dprintf("MOV: missing data (mdat) chunk! Maybe broken file...\n");
     534        else if(flags==2)
     535            dprintf("MOV: missing header (moov/cmov) chunk! Maybe broken file...\n");
     536
     537        return 0;
    214538    }
    215539
    216     // workaround for fixed-size video frames (dv and uncompressed)
    217     if(!trak->samples_size && trak->type!=MOV_TRAK_AUDIO){
    218         trak->samples_size=s;
    219         trak->samples=calloc(s, sizeof(mov_sample_t));
    220         for(i=0;i<s;i++)
    221             trak->samples[i].size=trak->samplesize;
    222         trak->samplesize=0;
     540    static void demux_close_mov(demuxer_t *demuxer) {
     541        mov_priv_t* priv = demuxer->priv;
     542        int i;
     543        if (!priv)
     544            return;
     545        for (i = 0; i < MOV_MAX_TRACKS; i++) {
     546            mov_track_t *track = priv->tracks[i];
     547            if (track) {
     548                free(track->tkdata);
     549                free(track->stdata);
     550                free(track->stream_header);
     551                free(track->samples);
     552                free(track->chunks);
     553                free(track->chunkmap);
     554                free(track->durmap);
     555                free(track->keyframes);
     556                free(track->editlist);
     557                free(track->desc);
     558                free(track);
     559            }
     560        }
     561        free(priv);
    223562    }
    224563
    225     if(!trak->samples_size){
    226         // constant sampesize
    227         if(trak->durmap_size==1 || (trak->durmap_size==2 && trak->durmap[1].num==1)){
    228             trak->duration=trak->durmap[0].dur;
    229         } else dprintf( "*** constant samplesize & variable duration not yet supported! ***\nContact the author if you have such sample file!\n");
    230         return;
     564    unsigned int store_ughvlc(unsigned char *s, unsigned int v){
     565        unsigned int n = 0;
     566
     567        while(v >= 0xff) {
     568            *s++ = 0xff;
     569            v -= 0xff;
     570            n++;
     571        }
     572        *s = v;
     573        n++;
     574
     575        return n;
    231576    }
    232577
    233     if (trak->samples_size < s) {
    234       dprintf(
    235              "MOV: durmap or chunkmap bigger than sample count (%i vs %i)\n",
    236              s, trak->samples_size);
    237       trak->samples_size = s;
    238       trak->samples = realloc_struct(trak->samples, s, sizeof(mov_sample_t));
     578    static void init_vobsub(sh_sub_t *sh, mov_track_t *trak) {
     579        int i;
     580        uint8_t *pal = trak->stdata;
     581        sh->type = 'v';
     582        if (trak->stdata_len < 106)
     583            return;
     584        sh->has_palette = 1;
     585        pal += 42;
     586        for (i = 0; i < 16; i++) {
     587            sh->palette[i] = BE_32(pal);
     588            pal += 4;
     589        }
    239590    }
    240 
    241     // calc pts:
    242     s=0;
    243     for(j=0;j<trak->durmap_size;j++){
    244         for(i=0;i<trak->durmap[j].num;i++){
    245             trak->samples[s].pts=pts;
    246             ++s;
    247             pts+=trak->durmap[j].dur;
    248         }
    249     }
    250 
    251     // calc sample offsets
    252     s=0;
    253     for(j=0;j<trak->chunks_size;j++){
    254         off_t pos=trak->chunks[j].pos;
    255         for(i=0;i<trak->chunks[j].size;i++){
    256             trak->samples[s].pos=pos;
    257             dprintf( "Sample %5d: pts=%8d  off=0x%08X  size=%d\n",s,
    258                 trak->samples[s].pts,
    259                 (int)trak->samples[s].pos,
    260                 trak->samples[s].size);
    261             pos+=trak->samples[s].size;
    262             ++s;
    263         }
    264     }
    265 
    266     // precalc editlist entries
    267     if(trak->editlist_size>0){
    268         int frame=0;
    269         int e_pts=0;
    270         for(i=0;i<trak->editlist_size;i++){
    271             mov_editlist_t* el=&trak->editlist[i];
    272             int sample=0;
    273             int pts=el->pos;
    274             el->start_frame=frame;
    275             if(pts<0){
    276                 // skip!
    277                 el->frames=0; continue;
    278             }
    279             // find start sample
    280             for(;sample<trak->samples_size;sample++){
    281                 if(pts<=trak->samples[sample].pts) break;
    282             }
    283             el->start_sample=sample;
    284             el->pts_offset=((long long)e_pts*(long long)trak->timescale)/(long long)timescale-trak->samples[sample].pts;
    285             pts+=((long long)el->dur*(long long)trak->timescale)/(long long)timescale;
    286             e_pts+=el->dur;
    287             // find end sample
    288             for(;sample<trak->samples_size;sample++){
    289                 if(pts<trak->samples[sample].pts) break;
    290             }
    291             el->frames=sample-el->start_sample;
    292             frame+=el->frames;
    293             dprintf("EL#%d: pts=%d  1st_sample=%d  frames=%d (%5.3fs)  pts_offs=%d\n",i,
    294                 el->pos,el->start_sample, el->frames,
    295                 (float)(el->dur)/(float)timescale, el->pts_offset);
    296         }
    297     }
    298 
    299 }
    300 
    301 #define MOV_MAX_TRACKS 256
    302 
    303 typedef struct {
    304     off_t moov_start;
    305     off_t moov_end;
    306     off_t mdat_start;
    307     off_t mdat_end;
    308     int track_db;
    309     mov_track_t* tracks[MOV_MAX_TRACKS];
    310     int timescale; // movie timescale
    311     int duration;  // movie duration (in movie timescale units)
    312 } mov_priv_t;
    313 
    314 #define MOV_FOURCC(a,b,c,d) ((a<<24)|(b<<16)|(c<<8)|(d))
    315 
    316 static int mov_check_file(demuxer_t* demuxer){
    317     int flags=0;
    318     int no=0;
    319     mov_priv_t* priv=malloc(sizeof(mov_priv_t));
    320 
    321     dprintf("Checking for MOV\n");
    322 
    323     memset(priv,0,sizeof(mov_priv_t));
    324 
    325     while(1){
    326         int i;
    327         int skipped=8;
    328         off_t len=stream_read_dword(demuxer->stream);
    329         unsigned int id=stream_read_dword(demuxer->stream);
    330         if(stream_eof(demuxer->stream)) break; // EOF
    331         if (len == 1) /* real size is 64bits - cjb */
    332         {
    333 #ifndef _LARGEFILE_SOURCE
    334             if (stream_read_dword(demuxer->stream) != 0)
    335                 dprintf( "64bit file, but you've compiled MPlayer without LARGEFILE support!\n");
    336             len = stream_read_dword(demuxer->stream);
    337 #else
    338             len = stream_read_qword(demuxer->stream);
     591                 
     592    static int lschunks_intrak(demuxer_t* demuxer, int level, unsigned int id,
     593                               off_t pos, off_t len, mov_track_t* trak);
     594
     595    static void lschunks(demuxer_t* demuxer,int level,off_t endpos,mov_track_t* trak){
     596        mov_priv_t* priv=demuxer->priv;
     597        //    printf("lschunks (level=%d,endpos=%x)\n", level, endpos);
     598        while(1){
     599            off_t pos;
     600            off_t len;
     601            unsigned int id;
     602            //
     603            pos=stream_tell(demuxer->stream);
     604            dprintf("MOV: stream_tell==%lli\n",pos);
     605            if(pos>=endpos) return; // END
     606            len=stream_read_dword(demuxer->stream);
     607            //  printf("len==%d\n",len);
     608            if(len<8) return; // error
     609            len-=8;
     610            id=stream_read_dword(demuxer->stream);
     611            //
     612            dprintf("lschunks %.4s  %d\n",(char *)&id,(int)len);
     613            //
     614            if(trak){
     615                if (lschunks_intrak(demuxer, level, id, pos, len, trak) < 0)
     616                    return;
     617            } else { /* not in track */
     618                switch(id) {
     619                case MOV_FOURCC('m','v','h','d'): {
     620                    int version = stream_read_char(demuxer->stream);
     621                    stream_skip(demuxer->stream, (version == 1) ? 19 : 11);
     622                    priv->timescale=stream_read_dword(demuxer->stream);
     623                    if (version == 1)
     624                        priv->duration=stream_read_qword(demuxer->stream);
     625                    else
     626                        priv->duration=stream_read_dword(demuxer->stream);
     627                    dprintf("MOV: %*sMovie header (%d bytes): tscale=%d  dur=%d\n",level,"",(int)len,
     628                            (int)priv->timescale,(int)priv->duration);
     629                    break;
     630                }
     631                case MOV_FOURCC('t','r','a','k'): {
     632                    //      if(trak) printf("MOV: Warning! trak in trak?\n");
     633                    if(priv->track_db>=MOV_MAX_TRACKS){
     634                        dprintf("MOV: too may tracks\n");
     635                        return;
     636                    }
     637                    if(!priv->track_db) dprintf( "--------------\n");
     638                    trak=malloc(sizeof(mov_track_t));
     639                    memset(trak,0,sizeof(mov_track_t));
     640                    dprintf("MOV: Track #%d:\n",priv->track_db);
     641                    trak->id=priv->track_db;
     642                    priv->tracks[priv->track_db]=trak;
     643                    lschunks(demuxer,level+1,pos+len,trak);
     644                    mov_build_index(trak,priv->timescale);
     645                    switch(trak->type){
     646                    case MOV_TRAK_AUDIO: {
     647#if 0
     648                        struct {
     649                            int16_t version;            // 0 or 1 (version 1 is qt3.0+)
     650                            int16_t revision;           // 0
     651                            int32_t vendor_id;          // 0
     652                            int16_t channels;           // 1 or 2  (Mono/Stereo)
     653                            int16_t samplesize;         // 8 or 16 (8Bit/16Bit)
     654                            int16_t compression_id;     // if version 0 then 0
     655                            // if version 1 and vbr then -2 else 0
     656                            int16_t packet_size;                // 0
     657                            uint16_t sample_rate;       // samplerate (Hz)
     658                            // qt3.0+ (version == 1)
     659                            uint32_t samples_per_packet;        // 0 or num uncompressed samples in a packet
     660                            // if 0 below three values are also 0
     661                            uint32_t bytes_per_packet;  // 0 or num compressed bytes for one channel
     662                            uint32_t bytes_per_frame;   // 0 or num compressed bytes for all channels
     663                            // (channels * bytes_per_packet)
     664                            uint32_t bytes_per_sample;  // 0 or size of uncompressed sample
     665                            // if samples_per_packet and bytes_per_packet are constant (CBR)
     666                            // then bytes_per_frame and bytes_per_sample must be 0 (else is VBR)
     667                            // ---
     668                            // optional additional atom-based fields
     669                            // ([int32_t size,int32_t type,some data ],repeat)
     670                        } my_stdata;
    339671#endif
    340             skipped += 8;
    341         }
    342 #if 0
    343         else if (len == 0) /* deleted chunk */
    344         {
    345             /* XXX: CJB! is this right? - alex */
    346             goto skip_chunk;
    347         }
    348 #endif
    349         else if(len<8) break; // invalid chunk
    350 
    351         switch(id){
    352         case MOV_FOURCC('f','t','y','p'): {
    353           unsigned int tmp;
    354           // File Type Box (ftyp):
    355           // char[4]  major_brand          (eg. 'isom')
    356           // int      minor_version        (eg. 0x00000000)
    357           // char[4]  compatible_brands[]  (eg. 'mp41')
    358           // compatible_brands list spans to the end of box
    359 #if 1
    360           tmp = stream_read_dword(demuxer->stream);
    361           switch(tmp) {
    362             case MOV_FOURCC('i','s','o','m'):
    363               dprintf("ISO: File Type Major Brand: ISO Base Media\n");
    364               break;
    365             case MOV_FOURCC('m','p','4','1'):
    366               dprintf("ISO: File Type Major Brand: ISO/IEC 14496-1 (MPEG-4 system) v1\n");
    367               break;
    368             case MOV_FOURCC('m','p','4','2'):
    369               dprintf("ISO: File Type Major Brand: ISO/IEC 14496-1 (MPEG-4 system) v2\n");
    370               break;
    371             case MOV_FOURCC('M','4','A',' '):
    372               dprintf("ISO: File Type Major Brand: Apple iTunes AAC-LC Audio\n");
    373               break;
    374             case MOV_FOURCC('M','4','P',' '):
    375               dprintf("ISO: File Type Major Brand: Apple iTunes AAC-LC Protected Audio\n");
    376               break;
    377             case MOV_FOURCC('q','t',' ',' '):
    378               dprintf("ISO: File Type Major Brand: Original QuickTime\n");
    379               break;
    380             case MOV_FOURCC('3','g','p','1'):
    381               dprintf("ISO: File Type Major Brand: 3GPP Profile 1\n");
    382               break;
    383             case MOV_FOURCC('3','g','p','2'):
    384             case MOV_FOURCC('3','g','2','a'):
    385               dprintf("ISO: File Type Major Brand: 3GPP Profile 2\n");
    386               break;
    387             case MOV_FOURCC('3','g','p','3'):
    388               dprintf("ISO: File Type Major Brand: 3GPP Profile 3\n");
    389               break;
    390             case MOV_FOURCC('3','g','p','4'):
    391               dprintf("ISO: File Type Major Brand: 3GPP Profile 4\n");
    392               break;
    393             case MOV_FOURCC('3','g','p','5'):
    394               dprintf("ISO: File Type Major Brand: 3GPP Profile 5\n");
    395               break;
    396             case MOV_FOURCC('m','m','p','4'):
    397               dprintf("ISO: File Type Major Brand: Mobile ISO/IEC 14496-1 (MPEG-4 system)\n");
    398               break;
    399             default:
    400               tmp = be2me_32(tmp);
    401               dprintf("ISO: Unknown File Type Major Brand: %.4s\n",(char *)&tmp);
    402           }
    403           dprintf("ISO: File Type Minor Version: %d\n",
    404               stream_read_dword(demuxer->stream));
    405           skipped += 8;
    406           // List all compatible brands
    407           for(i = 0; i < ((len-16)/4); i++) {
    408             tmp = be2me_32(stream_read_dword(demuxer->stream));
    409             dprintf("ISO: File Type Compatible Brand #%d: %.4s\n",i,(char *)&tmp);
    410             skipped += 4;
    411           }
    412 #endif
    413           } break;
    414         case MOV_FOURCC('m','o','o','v'):
    415 //      case MOV_FOURCC('c','m','o','v'):
    416           dprintf("MOV: Movie header found!\n");
    417           priv->moov_start=(off_t)stream_tell(demuxer->stream);
    418           priv->moov_end=(off_t)priv->moov_start+len-skipped;
    419           dprintf("MOV: Movie header: start: %"PRIx64" end: %"PRIx64"\n",
    420             (int64_t)priv->moov_start, (int64_t)priv->moov_end);
    421           skipped+=8;
    422           i = stream_read_dword(demuxer->stream)-8;
    423           if(stream_read_dword(demuxer->stream)==MOV_FOURCC('r','m','r','a')){
    424               int ref=0;
    425               skipped+=i;
    426               dprintf("MOV: Reference Media file!!!\n");
    427               //set demuxer type to playlist ...
    428               demuxer->type=DEMUXER_TYPE_PLAYLIST;
    429               while(i>0){
    430                   int len=stream_read_dword(demuxer->stream)-8;
    431                   int fcc=stream_read_dword(demuxer->stream);
    432                   if(len<0) break; // EOF!?
    433                   i-=8;
    434 //                printf("i=%d  len=%d\n",i,len);
    435                   switch(fcc){
    436                   case MOV_FOURCC('r','m','d','a'):
    437                       continue;
    438                   case MOV_FOURCC('r','d','r','f'): {
    439                       int tmp=stream_read_dword(demuxer->stream);
    440                       int type=stream_read_dword_le(demuxer->stream);
    441                       int slen=stream_read_dword(demuxer->stream);
    442                       //char* s=malloc(slen+1);
    443                       //stream_read(demuxer->stream,s,slen);
    444 
    445                       //FIXME: also store type & data_rate ?
    446                       ds_read_packet(demuxer->video,
    447                         demuxer->stream,
    448                         slen,
    449                         0,
    450                         stream_tell(demuxer->stream),
    451                         0 // no flags
    452                       );
    453                       flags|=4;
    454                       dprintf("Added reference to playlist\n");
    455                       //s[slen]=0;
    456                       //dprintf("REF: [%.4s] %s\n",&type,s);
    457                       len-=12+slen;i-=12+slen; break;
    458                     }
    459                   case MOV_FOURCC('r','m','d','r'): {
    460                       int flags=stream_read_dword(demuxer->stream);
    461                       int rate=stream_read_dword(demuxer->stream);
    462                       dprintf("  min. data rate: %d bits/sec\n",rate);
    463                       len-=8; i-=8; break;
    464                     }
    465                   case MOV_FOURCC('r','m','q','u'): {
    466                       int q=stream_read_dword(demuxer->stream);
    467                       dprintf("  quality index: %d\n",q);
    468                       len-=4; i-=4; break;
    469                     }
    470                   }
    471                   i-=len;stream_skip(demuxer->stream,len);
    472               }
    473           }
    474           flags|=1;
    475           break;
    476         case MOV_FOURCC('w','i','d','e'):
    477           dprintf("MOV: 'WIDE' chunk found!\n");
    478           if(flags&2) break;
    479         case MOV_FOURCC('m','d','a','t'):
    480           dprintf("MOV: Movie DATA found!\n");
    481           priv->mdat_start=stream_tell(demuxer->stream);
    482           priv->mdat_end=priv->mdat_start+len-skipped;
    483           dprintf("MOV: Movie data: start: %"PRIx64" end: %"PRIx64"\n",
    484             (int64_t)priv->mdat_start, (int64_t)priv->mdat_end);
    485           flags|=2;
    486           if(flags==3){
    487             // if we're over the headers, then we can stop parsing here!
    488             demuxer->priv=priv;
    489             return DEMUXER_TYPE_MOV;
    490           }
    491           break;
    492         case MOV_FOURCC('f','r','e','e'):
    493         case MOV_FOURCC('s','k','i','p'):
    494         case MOV_FOURCC('j','u','n','k'):
    495           dprintf("MOV: free space (len: %"PRId64")\n", (int64_t)len);
    496           /* unused, if you edit a mov, you can use space provided by free atoms (redefining it) */
    497           break;
    498         case MOV_FOURCC('p','n','o','t'):
    499         case MOV_FOURCC('P','I','C','T'):
    500           /* dunno what, but we shoudl ignore it */
    501           break;
    502         default:
    503           if(no==0){ free(priv); return 0;} // first chunk is bad!
    504           id = be2me_32(id);
    505           dprintf("MOV: unknown chunk: %.4s %d\n",(char *)&id,(int)len);
    506         }
    507 skip_chunk:
    508         if(!stream_skip(demuxer->stream,len-skipped)) break;
    509         ++no;
    510     }
    511 
    512     if(flags==3){
    513         demuxer->priv=priv;
    514         return DEMUXER_TYPE_MOV;
    515     }
    516     free(priv);
    517 
    518     if ((flags==5) || (flags==7)) // reference & header sent
    519         return DEMUXER_TYPE_PLAYLIST;
    520 
    521     if(flags==1)
    522         dprintf("MOV: missing data (mdat) chunk! Maybe broken file...\n");
    523     else if(flags==2)
    524         dprintf("MOV: missing header (moov/cmov) chunk! Maybe broken file...\n");
    525 
    526     return 0;
    527 }
    528 
    529 static void demux_close_mov(demuxer_t *demuxer) {
    530   mov_priv_t* priv = demuxer->priv;
    531   int i;
    532   if (!priv)
    533     return;
    534   for (i = 0; i < MOV_MAX_TRACKS; i++) {
    535     mov_track_t *track = priv->tracks[i];
    536     if (track) {
    537       free(track->tkdata);
    538       free(track->stdata);
    539       free(track->stream_header);
    540       free(track->samples);
    541       free(track->chunks);
    542       free(track->chunkmap);
    543       free(track->durmap);
    544       free(track->keyframes);
    545       free(track->editlist);
    546       free(track->desc);
    547       free(track);
    548     }
    549   }
    550   free(priv);
    551 }
    552 
    553 unsigned int store_ughvlc(unsigned char *s, unsigned int v){
    554     unsigned int n = 0;
    555 
    556     while(v >= 0xff) {
    557         *s++ = 0xff;
    558         v -= 0xff;
    559         n++;
    560     }
    561     *s = v;
    562     n++;
    563 
    564     return n;
    565 }
    566 
    567 static int lschunks_intrak(demuxer_t* demuxer, int level, unsigned int id,
    568                            off_t pos, off_t len, mov_track_t* trak);
    569 
    570 static void lschunks(demuxer_t* demuxer,int level,off_t endpos,mov_track_t* trak){
    571     mov_priv_t* priv=demuxer->priv;
    572     //    printf("lschunks (level=%d,endpos=%x)\n", level, endpos);
    573     while(1){
    574         off_t pos;
    575         off_t len;
    576         unsigned int id;
    577         //
    578         pos=stream_tell(demuxer->stream);
    579         dprintf("MOV: stream_tell==%lli\n",pos);
    580         if(pos>=endpos) return; // END
    581         len=stream_read_dword(demuxer->stream);
    582         //      printf("len==%d\n",len);
    583         if(len<8) return; // error
    584         len-=8;
    585         id=stream_read_dword(demuxer->stream);
    586         //
    587         dprintf("lschunks %.4s  %d\n",(char *)&id,(int)len);
    588         //
    589         if(trak){
    590             if (lschunks_intrak(demuxer, level, id, pos, len, trak) < 0)
    591                 return;
    592         } else { /* not in track */
    593             switch(id) {
    594             case MOV_FOURCC('m','v','h','d'): {
    595                 int version = stream_read_char(demuxer->stream);
    596                 stream_skip(demuxer->stream, (version == 1) ? 19 : 11);
    597                 priv->timescale=stream_read_dword(demuxer->stream);
    598                 if (version == 1)
    599                     priv->duration=stream_read_qword(demuxer->stream);
    600                 else
    601                     priv->duration=stream_read_dword(demuxer->stream);
    602                 dprintf("MOV: %*sMovie header (%d bytes): tscale=%d  dur=%d\n",level,"",(int)len,
    603                         (int)priv->timescale,(int)priv->duration);
    604                 break;
    605             }
    606             case MOV_FOURCC('t','r','a','k'): {
    607                 //          if(trak) printf("MOV: Warning! trak in trak?\n");
    608                 if(priv->track_db>=MOV_MAX_TRACKS){
    609                     dprintf("MOV: too may tracks\n");
    610                     return;
    611                 }
    612                 if(!priv->track_db) dprintf( "--------------\n");
    613                 trak=malloc(sizeof(mov_track_t));
    614                 memset(trak,0,sizeof(mov_track_t));
    615                 dprintf("MOV: Track #%d:\n",priv->track_db);
    616                 trak->id=priv->track_db;
    617                 priv->tracks[priv->track_db]=trak;
    618                 lschunks(demuxer,level+1,pos+len,trak);
    619                 mov_build_index(trak,priv->timescale);
    620                 switch(trak->type){
    621                 case MOV_TRAK_AUDIO: {
    622 #if 0
    623                     struct {
    624                         int16_t version;                // 0 or 1 (version 1 is qt3.0+)
    625                         int16_t revision;               // 0
    626                         int32_t vendor_id;              // 0
    627                         int16_t channels;               // 1 or 2  (Mono/Stereo)
    628                         int16_t samplesize;             // 8 or 16 (8Bit/16Bit)
    629                         int16_t compression_id; // if version 0 then 0
    630                         // if version 1 and vbr then -2 else 0
    631                         int16_t packet_size;            // 0
    632                         uint16_t sample_rate;   // samplerate (Hz)
    633                         // qt3.0+ (version == 1)
    634                         uint32_t samples_per_packet;    // 0 or num uncompressed samples in a packet
    635                         // if 0 below three values are also 0
    636                         uint32_t bytes_per_packet;      // 0 or num compressed bytes for one channel
    637                         uint32_t bytes_per_frame;       // 0 or num compressed bytes for all channels
    638                         // (channels * bytes_per_packet)
    639                         uint32_t bytes_per_sample;      // 0 or size of uncompressed sample
    640                         // if samples_per_packet and bytes_per_packet are constant (CBR)
    641                         // then bytes_per_frame and bytes_per_sample must be 0 (else is VBR)
    642                         // ---
    643                         // optional additional atom-based fields
    644                         // ([int32_t size,int32_t type,some data ],repeat)
    645                     } my_stdata;
    646 #endif
    647                     int version, adjust;
    648                     int is_vorbis = 0;
    649                     sh_audio_t* sh=new_sh_audio(demuxer,priv->track_db);
    650                     sh->format=trak->fourcc;
    651 
    652                     // crude audio delay from editlist0 hack ::atm
    653                     if(trak->editlist_size>=1) {
    654                         if(trak->editlist[0].pos == -1) {
    655                             sh->stream_delay = (float)trak->editlist[0].dur/(float)priv->timescale;
    656                             dprintf("MOV: Initial Audio-Delay: %.3f sec\n", sh->stream_delay);
     672                        int version, adjust;
     673                        int is_vorbis = 0;
     674                        sh_audio_t* sh=new_sh_audio(demuxer,priv->track_db);
     675                        sh->format=trak->fourcc;
     676
     677                        // crude audio delay from editlist0 hack ::atm
     678                        if(trak->editlist_size>=1) {
     679                            if(trak->editlist[0].pos == -1) {
     680                                sh->stream_delay = (float)trak->editlist[0].dur/(float)priv->timescale;
     681                                dprintf("MOV: Initial Audio-Delay: %.3f sec\n", sh->stream_delay);
     682                            }
    657683                        }
    658                     }
    659 
    660                     switch( sh->format ) {
    661                     case 0x726D6173: /* samr */
    662                         /* amr narrowband */
    663                         trak->samplebytes=sh->samplesize=1;
    664                         trak->nchannels=sh->channels=1;
    665                         sh->samplerate=8000;
    666                         break;
    667 
    668                     case 0x62776173: /* sawb */
    669                         /* amr wideband */
    670                         trak->samplebytes=sh->samplesize=1;
    671                         trak->nchannels=sh->channels=1;
    672                         sh->samplerate=16000;
    673                         break;
    674 
    675                     default:
    676 
    677                         // assumptions for below table: short is 16bit, int is 32bit, intfp is 16bit
    678                         // XXX: 32bit fixed point numbers (intfp) are only 2 Byte!
    679                         // short values are usually one byte leftpadded by zero
    680                         //   int values are usually two byte leftpadded by zero
    681                         //  stdata[]:
    682                         //      8   short       version
    683                         //      10  short       revision
    684                         //      12  int         vendor_id
    685                         //      16  short       channels
    686                         //      18  short       samplesize
    687                         //      20  short       compression_id
    688                         //      22  short       packet_size (==0)
    689                         //      24  intfp       sample_rate
    690                         //     (26  short)      unknown (==0)
    691                         //    ---- qt3.0+ (version>=1)
    692                         //      28  int         samples_per_packet
    693                         //      32  int         bytes_per_packet
    694                         //      36  int         bytes_per_frame
    695                         //      40  int         bytes_per_sample
    696                         // there may be additional atoms following at 28 (version 0)
    697                         // or 44 (version 1), eg. esds atom of .MP4 files
    698                         // esds atom:
    699                         //      28  int         atom size (bytes of int size, int type and data)
    700                         //      32  char[4]     atom type (fourc charater code -> esds)
    701                         //      36  char[]      atom data (len=size-8)
    702 
    703                         // TODO: fix parsing for files using version 2.
    704                         version=char2short(trak->stdata,8);
    705                         if (version > 1)
    706                             dprintf( "MOV: version %d sound atom may not parse correctly!\n", version);
    707                         trak->samplebytes=sh->samplesize=char2short(trak->stdata,18)/8;
    708 
    709                         /* I can't find documentation, but so far this is the case. -Corey */
    710                         switch (char2short(trak->stdata,16)) {
    711                         case 1:
    712                             trak->nchannels = 1; break;
    713                         case 2:
    714                             trak->nchannels = 2; break;
    715                         case 3:
    716                             trak->nchannels = 6; break;
     684
     685                        switch( sh->format ) {
     686                        case 0x726D6173: /* samr */
     687                            /* amr narrowband */
     688                            trak->samplebytes=sh->samplesize=1;
     689                            trak->nchannels=sh->channels=1;
     690                            sh->samplerate=8000;
     691                            break;
     692
     693                        case 0x62776173: /* sawb */
     694                            /* amr wideband */
     695                            trak->samplebytes=sh->samplesize=1;
     696                            trak->nchannels=sh->channels=1;
     697                            sh->samplerate=16000;
     698                            break;
     699
    717700                        default:
    718                             dprintf(
    719                                     "MOV: unable to determine audio channels, assuming 2 (got %d)\n",
    720                                     char2short(trak->stdata,16));
    721                             trak->nchannels = 2;
    722                         }
    723                         sh->channels = trak->nchannels;
    724 
    725                         /*printf("MOV: timescale: %d samplerate: %d durmap: %d (%d) -> %d (%d)\n",
    726                          trak->timescale, char2short(trak->stdata,24), trak->durmap[0].dur,
    727                          trak->durmap[0].num, trak->timescale/trak->durmap[0].dur,
    728                          char2short(trak->stdata,24)/trak->durmap[0].dur);*/
    729                         sh->samplerate=char2short(trak->stdata,24);
    730                         if((sh->samplerate < 7000) && trak->durmap) {
    731                             switch(char2short(trak->stdata,24)/trak->durmap[0].dur) {
    732                                 // TODO: add more cases.
    733                             case 31:
    734                                 sh->samplerate = 32000; break;
    735                             case 43:
    736                                 sh->samplerate = 44100; break;
    737                             case 47:
    738                                 sh->samplerate = 48000; break;
     701
     702                            // assumptions for below table: short is 16bit, int is 32bit, intfp is 16bit
     703                            // XXX: 32bit fixed point numbers (intfp) are only 2 Byte!
     704                            // short values are usually one byte leftpadded by zero
     705                            //   int values are usually two byte leftpadded by zero
     706                            //  stdata[]:
     707                            //  8   short       version
     708                            //  10  short       revision
     709                            //  12  int         vendor_id
     710                            //  16  short       channels
     711                            //  18  short       samplesize
     712                            //  20  short       compression_id
     713                            //  22  short       packet_size (==0)
     714                            //  24  intfp       sample_rate
     715                            //     (26  short)  unknown (==0)
     716                            //    ---- qt3.0+ (version>=1)
     717                            //  28  int         samples_per_packet
     718                            //  32  int         bytes_per_packet
     719                            //  36  int         bytes_per_frame
     720                            //  40  int         bytes_per_sample
     721                            // there may be additional atoms following at 28 (version 0)
     722                            // or 44 (version 1), eg. esds atom of .MP4 files
     723                            // esds atom:
     724                            //      28  int             atom size (bytes of int size, int type and data)
     725                            //      32  char[4] atom type (fourc charater code -> esds)
     726                            //      36  char[]          atom data (len=size-8)
     727
     728                            // TODO: fix parsing for files using version 2.
     729                            version=char2short(trak->stdata,8);
     730                            if (version > 1)
     731                                dprintf( "MOV: version %d sound atom may not parse correctly!\n", version);
     732                            trak->samplebytes=sh->samplesize=char2short(trak->stdata,18)/8;
     733
     734                            /* I can't find documentation, but so far this is the case. -Corey */
     735                            switch (char2short(trak->stdata,16)) {
     736                            case 1:
     737                                trak->nchannels = 1; break;
     738                            case 2:
     739                                trak->nchannels = 2; break;
     740                            case 3:
     741                                trak->nchannels = 6; break;
    739742                            default:
    740743                                dprintf(
    741                                         "MOV: unable to determine audio samplerate, "
    742                                         "assuming 44.1kHz (got %d)\n",
    743                                         char2short(trak->stdata,24)/trak->durmap[0].dur);
    744                                 sh->samplerate = 44100;
     744                                        "MOV: unable to determine audio channels, assuming 2 (got %d)\n",
     745                                        char2short(trak->stdata,16));
     746                                trak->nchannels = 2;
     747                            }
     748                            sh->channels = trak->nchannels;
     749
     750                            /*printf("MOV: timescale: %d samplerate: %d durmap: %d (%d) -> %d (%d)\n",
     751                             trak->timescale, char2short(trak->stdata,24), trak->durmap[0].dur,
     752                             trak->durmap[0].num, trak->timescale/trak->durmap[0].dur,
     753                             char2short(trak->stdata,24)/trak->durmap[0].dur);*/
     754                            sh->samplerate=char2short(trak->stdata,24);
     755                            if((sh->samplerate < 7000) && trak->durmap) {
     756                                switch(char2short(trak->stdata,24)/trak->durmap[0].dur) {
     757                                    // TODO: add more cases.
     758                                case 31:
     759                                    sh->samplerate = 32000; break;
     760                                case 43:
     761                                    sh->samplerate = 44100; break;
     762                                case 47:
     763                                    sh->samplerate = 48000; break;
     764                                default:
     765                                    dprintf(
     766                                            "MOV: unable to determine audio samplerate, "
     767                                            "assuming 44.1kHz (got %d)\n",
     768                                            char2short(trak->stdata,24)/trak->durmap[0].dur);
     769                                    sh->samplerate = 44100;
     770                                }
    745771                            }
    746772                        }
    747                     }
    748                     dprintf( "Audio bits: %d  chans: %d  rate: %d\n",
    749                             sh->samplesize*8,sh->channels,sh->samplerate);
    750 
    751                     if(trak->stdata_len >= 44 && trak->stdata[9]>=1){
    752                         dprintf("Audio header: samp/pack=%d bytes/pack=%d bytes/frame=%d bytes/samp=%d  \n",
    753                                 char2int(trak->stdata,28),
    754                                 char2int(trak->stdata,32),
    755                                 char2int(trak->stdata,36),
    756                                 char2int(trak->stdata,40));
    757                         if(trak->stdata_len>=44+8){
    758                             int len=char2int(trak->stdata,44);
    759                             int fcc=char2int(trak->stdata,48);
    760                             // we have extra audio headers!!!
    761                             dprintf("Audio extra header: len=%d  fcc=0x%X\n",len,fcc);
    762                             if((len >= 4) &&
    763                                (char2int(trak->stdata,52) >= 12) &&
    764                                (char2int(trak->stdata,52+4) == MOV_FOURCC('f','r','m','a'))) {
    765                                 switch(char2int(trak->stdata,52+8)) {
    766                                 case MOV_FOURCC('a','l','a','c'):
    767                                     if (len >= 36 + char2int(trak->stdata,52)) {
    768                                         sh->codecdata_len = char2int(trak->stdata,52+char2int(trak->stdata,52));
    769                                         dprintf( "MOV: Found alac atom (%d)!\n", sh->codecdata_len);
    770                                         sh->codecdata = (unsigned char *)malloc(sh->codecdata_len);
    771                                         memcpy(sh->codecdata, &trak->stdata[52+char2int(trak->stdata,52)], sh->codecdata_len);
     773                        dprintf( "Audio bits: %d  chans: %d  rate: %d\n",
     774                                sh->samplesize*8,sh->channels,sh->samplerate);
     775
     776                        if(trak->stdata_len >= 44 && trak->stdata[9]>=1){
     777                            dprintf("Audio header: samp/pack=%d bytes/pack=%d bytes/frame=%d bytes/samp=%d  \n",
     778                                    char2int(trak->stdata,28),
     779                                    char2int(trak->stdata,32),
     780                                    char2int(trak->stdata,36),
     781                                    char2int(trak->stdata,40));
     782                            if(trak->stdata_len>=44+8){
     783                                int len=char2int(trak->stdata,44);
     784                                int fcc=char2int(trak->stdata,48);
     785                                // we have extra audio headers!!!
     786                                dprintf("Audio extra header: len=%d  fcc=0x%X\n",len,fcc);
     787                                if((len >= 4) &&
     788                                   (char2int(trak->stdata,52) >= 12) &&
     789                                   (char2int(trak->stdata,52+4) == MOV_FOURCC('f','r','m','a'))) {
     790                                    switch(char2int(trak->stdata,52+8)) {
     791                                    case MOV_FOURCC('a','l','a','c'):
     792                                        if (len >= 36 + char2int(trak->stdata,52)) {
     793                                            sh->codecdata_len = char2int(trak->stdata,52+char2int(trak->stdata,52));
     794                                            dprintf( "MOV: Found alac atom (%d)!\n", sh->codecdata_len);
     795                                            sh->codecdata = (unsigned char *)malloc(sh->codecdata_len);
     796                                            memcpy(sh->codecdata, &trak->stdata[52+char2int(trak->stdata,52)], sh->codecdata_len);
     797                                        }
     798                                        break;
     799                                    case MOV_FOURCC('i','n','2','4'):
     800                                    case MOV_FOURCC('i','n','3','2'):
     801                                    case MOV_FOURCC('f','l','3','2'):
     802                                    case MOV_FOURCC('f','l','6','4'):
     803                                        if ((len >= 22) &&
     804                                            (char2int(trak->stdata,52+16)==MOV_FOURCC('e','n','d','a')) &&
     805                                            (char2short(trak->stdata,52+20))) {
     806                                            sh->format=char2int(trak->stdata,52+8);
     807                                            dprintf( "MOV: Found little endian PCM data, reversed fourcc:%04x\n", sh->format);
     808                                        }
     809                                        break;
     810                                    default:
     811                                        if (len > 8 && len + 44 <= trak->stdata_len) {
     812                                            sh->codecdata_len = len-8;
     813                                            sh->codecdata = trak->stdata+44+8;
     814                                        }
    772815                                    }
    773                                     break;
    774                                 case MOV_FOURCC('i','n','2','4'):
    775                                 case MOV_FOURCC('i','n','3','2'):
    776                                 case MOV_FOURCC('f','l','3','2'):
    777                                 case MOV_FOURCC('f','l','6','4'):
    778                                     if ((len >= 22) &&
    779                                         (char2int(trak->stdata,52+16)==MOV_FOURCC('e','n','d','a')) &&
    780                                         (char2short(trak->stdata,52+20))) {
    781                                         sh->format=char2int(trak->stdata,52+8);
    782                                         dprintf( "MOV: Found little endian PCM data, reversed fourcc:%04x\n", sh->format);
    783                                     }
    784                                     break;
    785                                 default:
     816                                } else {
    786817                                    if (len > 8 && len + 44 <= trak->stdata_len) {
    787818                                        sh->codecdata_len = len-8;
    … …  
    789820                                    }
    790821                                }
    791                             } else {
    792                                 if (len > 8 && len + 44 <= trak->stdata_len) {
    793                                     sh->codecdata_len = len-8;
    794                                     sh->codecdata = trak->stdata+44+8;
     822                            }
     823                        }
     824
     825                        switch (version) {
     826                        case 0:
     827                            adjust =  0; break;
     828                        case 1:
     829                            adjust = 48; break;
     830                        case 2:
     831                            adjust = 68; break;
     832                        default:
     833                            dprintf( "MOV: unknown sound atom version (%d); may not work!\n", version);
     834                            adjust = 68;
     835                        }
     836                        if (trak->stdata_len >= 36 + adjust) {
     837                            int atom_len = char2int(trak->stdata,28+adjust);
     838                            switch(char2int(trak->stdata,32+adjust)) { // atom type
     839                            case MOV_FOURCC('e','s','d','s'): {
     840                                dprintf( "MOV: Found MPEG4 audio Elementary Stream Descriptor atom (%d)!\n", atom_len);
     841                                if(atom_len > 8) {
     842                                    esds_t esds;
     843                                    if(!mp4_parse_esds(&trak->stdata[36+adjust], atom_len-8, &esds)) {
     844                                        /* 0xdd is a "user private" id, not an official allocated id (see http://www.mp4ra.org/object.html),
     845                                         so perform some extra checks to be sure that this is really vorbis audio */
     846                                        if(esds.objectTypeId==0xdd && esds.streamType==0x15 && sh->format==0x6134706D && esds.decoderConfigLen > 8)
     847                                        {
     848                                            //vorbis audio
     849                                            unsigned char *buf[3];
     850                                            unsigned short sizes[3];
     851                                            int offset, len, k;
     852                                            unsigned char *ptr = esds.decoderConfig;
     853
     854                                            if(ptr[0] != 0 || ptr[1] != 30) goto quit_vorbis_block; //wrong extradata layout
     855
     856                                            offset = len = 0;
     857                                            for(k = 0; k < 3; k++)
     858                                            {
     859                                                sizes[k] = (ptr[offset]<<8) | ptr[offset+1];
     860                                                len += sizes[k];
     861                                                offset += 2;
     862                                                if(offset + sizes[k] > esds.decoderConfigLen)
     863                                                {
     864                                                    dprintf("MOV: ERROR!, not enough vorbis extradata to read: offset = %d, k=%d, size=%d, len: %d\n", offset, k, sizes[k], esds.decoderConfigLen);
     865                                                    goto quit_vorbis_block;
     866                                                }
     867                                                buf[k] = malloc(sizes[k]);
     868                                                if(!buf[k]) goto quit_vorbis_block;
     869                                                memcpy(buf[k], &ptr[offset], sizes[k]);
     870                                                offset += sizes[k];
     871                                            }
     872
     873                                            sh->codecdata_len = len + len/255 + 64;
     874                                            sh->codecdata = malloc(sh->codecdata_len);
     875                                            ptr = sh->codecdata;
     876
     877                                            ptr[0] = 2;
     878                                            offset = 1;
     879                                            offset += store_ughvlc(&ptr[offset], sizes[0]);
     880                                            offset += store_ughvlc(&ptr[offset], sizes[1]);
     881                                            for(k = 0; k < 3; k++)
     882                                            {
     883                                                memcpy(&ptr[offset], buf[k], sizes[k]);
     884                                                offset += sizes[k];
     885                                            }
     886
     887                                            sh->codecdata_len = offset;
     888                                            sh->codecdata = realloc(sh->codecdata, offset);
     889                                            dprintf("demux_mov, vorbis extradata size: %d\n", offset);
     890                                            is_vorbis = 1;
     891                                        quit_vorbis_block:
     892                                            sh->format = mmioFOURCC('v', 'r', 'b', 's');
     893                                        }
     894                                        sh->i_bps = esds.avgBitrate/8;
     895
     896                                        //                          printf("######## audio format = %d ########\n",esds.objectTypeId);
     897                                        if(esds.objectTypeId==MP4OTI_MPEG1Audio || esds.objectTypeId==MP4OTI_MPEG2AudioPart3)
     898                                            sh->format=0x55; // .mp3
     899                                        if(esds.objectTypeId==MP4OTI_13kVoice) { // 13K Voice, defined by 3GPP2
     900                                            sh->format=mmioFOURCC('Q', 'c', 'l', 'p');
     901                                            trak->nchannels=sh->channels=1;
     902                                            trak->samplebytes=sh->samplesize=1;
     903                                        }
     904
     905                                        // dump away the codec specific configuration for the AAC decoder
     906                                        if(esds.decoderConfigLen){
     907                                            if( (esds.decoderConfig[0]>>3) == 29 )
     908                                                sh->format = 0x1d61346d; // request multi-channel mp3 decoder
     909                                            if(!is_vorbis)
     910                                            {
     911                                                sh->codecdata_len = esds.decoderConfigLen;
     912                                                sh->codecdata = (unsigned char *)malloc(sh->codecdata_len);
     913                                                memcpy(sh->codecdata, esds.decoderConfig, sh->codecdata_len);
     914                                            }
     915                                        }
     916                                    }
     917                                    mp4_free_esds(&esds); // freeup esds mem
     918#if 0
     919                                    { FILE* f=fopen("esds.dat","wb");
     920                                        fwrite(&trak->stdata[36],atom_len-8,1,f);
     921                                    fclose(f); }
     922#endif
     923                                }
     924                            } break;
     925                            case MOV_FOURCC('a','l','a','c'): {
     926                                dprintf( "MOV: Found alac atom (%d)!\n", atom_len);
     927                                if(atom_len > 8) {
     928                                    // copy all the atom (not only payload) for lavc alac decoder
     929                                    sh->codecdata_len = atom_len;
     930                                    sh->codecdata = (unsigned char *)malloc(sh->codecdata_len);
     931                                    memcpy(sh->codecdata, &trak->stdata[28], sh->codecdata_len);
     932                                }
     933                            } break;
     934                            case MOV_FOURCC('d','a','m','r'):
     935                                dprintf( "MOV: Found AMR audio atom %c%c%c%c (%d)!\n", trak->stdata[32+adjust],trak->stdata[33+adjust],trak->stdata[34+adjust],trak->stdata[35+adjust], atom_len);
     936                                if (atom_len>14) {
     937                                    dprintf( "mov: vendor: %c%c%c%c Version: %d\n",trak->stdata[36+adjust],trak->stdata[37+adjust],trak->stdata[38+adjust], trak->stdata[39+adjust],trak->stdata[40+adjust]);
     938                                    dprintf( "MOV: Modes set: %02x%02x\n",trak->stdata[41+adjust],trak->stdata[42+adjust]);
     939                                    dprintf( "MOV: Mode change period: %d Frames per sample: %d\n",trak->stdata[43+adjust],trak->stdata[44+adjust]);
     940                                }
     941                                break;
     942                            default:
     943                                dprintf( "MOV: Found unknown audio atom %c%c%c%c (%d)!\n",
     944                                        trak->stdata[32+adjust],trak->stdata[33+adjust],trak->stdata[34+adjust],trak->stdata[35+adjust],
     945                                        atom_len);
     946                            }
     947                        }
     948                        dprintf( "Fourcc: %.4s\n",(char *)&trak->fourcc);
     949#if 0
     950                        { FILE* f=fopen("stdata.dat","wb");
     951                            fwrite(trak->stdata,trak->stdata_len,1,f);
     952                        fclose(f); }
     953                        { FILE* f=fopen("tkdata.dat","wb");
     954                            fwrite(trak->tkdata,trak->tkdata_len,1,f);
     955                        fclose(f); }
     956#endif
     957                        // Emulate WAVEFORMATEX struct:
     958                        sh->wf=malloc(sizeof(WAVEFORMATEX) + (is_vorbis ? sh->codecdata_len : 0));
     959                        memset(sh->wf,0,sizeof(WAVEFORMATEX));
     960                        sh->wf->nChannels=sh->channels;
     961                        sh->wf->wBitsPerSample=(trak->stdata[18]<<8)+trak->stdata[19];
     962                        // sh->wf->nSamplesPerSec=trak->timescale;
     963                        sh->wf->nSamplesPerSec=sh->samplerate;
     964                        if(trak->stdata_len >= 44 && trak->stdata[9]>=1 && char2int(trak->stdata,28)>0){
     965                            //Audio header: samp/pack=4096 bytes/pack=743 bytes/frame=1486 bytes/samp=2
     966                            sh->wf->nAvgBytesPerSec=(sh->wf->nChannels*sh->wf->nSamplesPerSec*
     967                                                     char2int(trak->stdata,32)+char2int(trak->stdata,28)/2)
     968                                /char2int(trak->stdata,28);
     969                            sh->wf->nBlockAlign=char2int(trak->stdata,36);
     970                        } else {
     971                            sh->wf->nAvgBytesPerSec=sh->wf->nChannels*sh->wf->wBitsPerSample*sh->wf->nSamplesPerSec/8;
     972                            // workaround for ms11 ima4
     973                            if (sh->format == 0x1100736d && trak->stdata_len >= 36)
     974                                sh->wf->nBlockAlign=char2int(trak->stdata,36);
     975                        }
     976                        if(is_vorbis && sh->codecdata_len)
     977                        {
     978                            memcpy(sh->wf+1, sh->codecdata, sh->codecdata_len);
     979                            sh->wf->cbSize = sh->codecdata_len;
     980                        }
     981                        // Selection:
     982                        //              if(demuxer->audio->id==-1 || demuxer->audio->id==priv->track_db){
     983                        //                  // (auto)selected audio track:
     984                        //                  demuxer->audio->id=priv->track_db;
     985                        //                  demuxer->audio->sh=sh; sh->ds=demuxer->audio;
     986                        //              }
     987                        break;
     988                    }
     989                    case MOV_TRAK_VIDEO: {
     990                        int i, entry;
     991                        int flag, start, count_flag, end, palette_count, gray;
     992                        int hdr_ptr = 76;  // the byte just after depth
     993                        unsigned char *palette_map;
     994                        sh_video_t* sh=new_sh_video(demuxer,priv->track_db);
     995                        int depth;
     996                        sh->format=trak->fourcc;
     997
     998                        // crude video delay from editlist0 hack ::atm
     999                        if(trak->editlist_size>=1) {
     1000                            if(trak->editlist[0].pos == -1) {
     1001                                sh->stream_delay = (float)trak->editlist[0].dur/(float)priv->timescale;
     1002                                dprintf("MOV: Initial Video-Delay: %.3f sec\n", sh->stream_delay);
     1003                            }
     1004                        }
     1005
     1006                        if (trak->stdata_len < 78) {
     1007                            dprintf("MOV: Invalid (%d bytes instead of >= 78) video trak desc\n",
     1008                                    trak->stdata_len);
     1009                            break;
     1010                        }
     1011                        depth = trak->stdata[75] | (trak->stdata[74] << 8);
     1012                        //  stdata[]:
     1013                        //      8   short       version
     1014                        //      10  short       revision
     1015                        //      12  int         vendor_id
     1016                        //      16  int         temporal_quality
     1017                        //      20  int         spatial_quality
     1018                        //      24  short       width
     1019                        //      26  short       height
     1020                        //      28  int         h_dpi
     1021                        //      32  int         v_dpi
     1022                        //      36  int         0
     1023                        //      40  short       frames_per_sample
     1024                        //      42  char[4]     compressor_name
     1025                        //      74  short       depth
     1026                        //      76  short       color_table_id
     1027                        // additional atoms may follow,
     1028                        // eg esds atom from .MP4 files
     1029                        //      78  int         atom size
     1030                        //      82  char[4]     atom type
     1031                        //      86  ...         atom data
     1032
     1033                        {       ImageDescription* id=malloc(8+trak->stdata_len);  // safe
     1034                            trak->desc=id;
     1035                        id->idSize=8+trak->stdata_len;
     1036                        //              id->cType=bswap_32(trak->fourcc);
     1037                        id->cType=le2me_32(trak->fourcc);
     1038                        id->version=char2short(trak->stdata,8);
     1039                        id->revisionLevel=char2short(trak->stdata,10);
     1040                        id->vendor=char2int(trak->stdata,12);
     1041                        id->temporalQuality=char2int(trak->stdata,16);
     1042                        id->spatialQuality=char2int(trak->stdata,20);
     1043                        id->width=char2short(trak->stdata,24);
     1044                        id->height=char2short(trak->stdata,26);
     1045                        id->hRes=char2int(trak->stdata,28);
     1046                        id->vRes=char2int(trak->stdata,32);
     1047                        id->dataSize=char2int(trak->stdata,36);
     1048                        id->frameCount=char2short(trak->stdata,40);
     1049                        memcpy(&id->name,trak->stdata+42,32);
     1050                        id->depth=char2short(trak->stdata,74);
     1051                        id->clutID=char2short(trak->stdata,76);
     1052                        if(trak->stdata_len>78) memcpy(((char*)&id->clutID)+2,trak->stdata+78,trak->stdata_len-78);
     1053                        sh->ImageDesc=id;
     1054#if 0
     1055                        {   FILE *f=fopen("ImageDescription","wb");
     1056                            fwrite(id,id->idSize,1,f);
     1057                        fclose(f);
     1058                        }
     1059#endif
     1060                        }
     1061
     1062                        if(trak->stdata_len >= 86) { // extra atoms found
     1063                            int pos=78;
     1064                            int atom_len;
     1065                            while(pos+8<=trak->stdata_len &&
     1066                                  (pos+(atom_len=char2int(trak->stdata,pos)))<=trak->stdata_len){
     1067                                switch(char2int(trak->stdata,pos+4)) { // switch atom type
     1068                                case MOV_FOURCC('g','a','m','a'):
     1069                                    // intfp with gamma value at which movie was captured
     1070                                    // can be used to gamma correct movie display
     1071                                    dprintf( "MOV: Found unsupported Gamma-Correction movie atom (%d)!\n",
     1072                                            atom_len);
     1073                                    break;
     1074                                case MOV_FOURCC('f','i','e','l'):
     1075                                    // 2 char-values (8bit int) that specify field handling
     1076                                    // see the Apple's QuickTime Fileformat PDF for more info
     1077                                    dprintf( "MOV: Found unsupported Field-Handling movie atom (%d)!\n",
     1078                                            atom_len);
     1079                                    break;
     1080                                case MOV_FOURCC('m','j','q','t'):
     1081                                    // Motion-JPEG default quantization table
     1082                                    dprintf( "MOV: Found unsupported MJPEG-Quantization movie atom (%d)!\n",
     1083                                            atom_len);
     1084                                    break;
     1085                                case MOV_FOURCC('m','j','h','t'):
     1086                                    // Motion-JPEG default huffman table
     1087                                    dprintf( "MOV: Found unsupported MJPEG-Huffman movie atom (%d)!\n",
     1088                                            atom_len);
     1089                                    break;
     1090                                case MOV_FOURCC('e','s','d','s'):
     1091                                    // MPEG4 Elementary Stream Descriptor header
     1092                                    dprintf( "MOV: Found MPEG4 movie Elementary Stream Descriptor atom (%d)!\n", atom_len);
     1093                                    // add code here to save esds header of length atom_len-8
     1094                                    // beginning at stdata[86] to some variable to pass it
     1095                                    // on to the decoder ::atmos
     1096                                    if(atom_len > 8) {
     1097                                        esds_t esds;
     1098                                        if(!mp4_parse_esds(trak->stdata+pos+8, atom_len-8, &esds)) {
     1099
     1100                                            if(esds.objectTypeId==MP4OTI_MPEG2VisualSimple || esds.objectTypeId==MP4OTI_MPEG2VisualMain ||
     1101                                               esds.objectTypeId==MP4OTI_MPEG2VisualSNR || esds.objectTypeId==MP4OTI_MPEG2VisualSpatial ||
     1102                                               esds.objectTypeId==MP4OTI_MPEG2VisualHigh || esds.objectTypeId==MP4OTI_MPEG2Visual422)
     1103                                                sh->format=mmioFOURCC('m', 'p', 'g', '2');
     1104                                            else if(esds.objectTypeId==MP4OTI_MPEG1Visual)
     1105                                                sh->format=mmioFOURCC('m', 'p', 'g', '1');
     1106
     1107                                            // dump away the codec specific configuration for the AAC decoder
     1108                                            trak->stream_header_len = esds.decoderConfigLen;
     1109                                            trak->stream_header = (unsigned char *)malloc(trak->stream_header_len);
     1110                                            memcpy(trak->stream_header, esds.decoderConfig, trak->stream_header_len);
     1111                                        }
     1112                                        mp4_free_esds(&esds); // freeup esds mem
     1113                                    }
     1114                                    break;
     1115                                case MOV_FOURCC('a','v','c','C'):
     1116                                    // AVC decoder configuration record
     1117                                    dprintf( "MOV: AVC decoder configuration record atom (%d)!\n", atom_len);
     1118                                    if(atom_len > 8) {
     1119                                        int i, poffs, cnt;
     1120                                        // Parse some parts of avcC, just for fun :)
     1121                                        // real parsing is done by avc1 decoder
     1122                                        dprintf( "MOV: avcC version: %d\n", *(trak->stdata+pos+8));
     1123                                        if (*(trak->stdata+pos+8) != 1)
     1124                                            dprintf( "MOV: unknown avcC version (%d). Expexct problems.\n", *(trak->stdata+pos+9));
     1125                                        dprintf( "MOV: avcC profile: %d\n", *(trak->stdata+pos+9));
     1126                                        dprintf( "MOV: avcC profile compatibility: %d\n", *(trak->stdata+pos+10));
     1127                                        dprintf( "MOV: avcC level: %d\n", *(trak->stdata+pos+11));
     1128                                        dprintf( "MOV: avcC nal length size: %d\n", ((*(trak->stdata+pos+12))&0x03)+1);
     1129                                        dprintf( "MOV: avcC number of sequence param sets: %d\n", cnt = (*(trak->stdata+pos+13) & 0x1f));
     1130                                        poffs = pos + 14;
     1131                                        for (i = 0; i < cnt; i++) {
     1132                                            dprintf( "MOV: avcC sps %d have length %d\n", i, BE_16(trak->stdata+poffs));
     1133                                            poffs += BE_16(trak->stdata+poffs) + 2;
     1134                                        }
     1135                                        dprintf( "MOV: avcC number of picture param sets: %d\n", *(trak->stdata+poffs));
     1136                                        poffs++;
     1137                                        for (i = 0; i < cnt; i++) {
     1138                                            dprintf( "MOV: avcC pps %d have length %d\n", i, BE_16(trak->stdata+poffs));
     1139                                            poffs += BE_16(trak->stdata+poffs) + 2;
     1140                                        }
     1141                                        // Copy avcC for the AVC decoder
     1142                                        // This data will be put in extradata below, where BITMAPINFOHEADER is created
     1143                                        trak->stream_header_len = atom_len-8;
     1144                                        trak->stream_header = (unsigned char *)malloc(trak->stream_header_len);
     1145                                        memcpy(trak->stream_header, trak->stdata+pos+8, trak->stream_header_len);
     1146                                    }
     1147                                    break;
     1148                                case MOV_FOURCC('d','2','6','3'):
     1149                                    dprintf( "MOV: Found H.263 decoder atom %c%c%c%c (%d)!\n", trak->stdata[pos+4],trak->stdata[pos+5],trak->stdata[pos+6],trak->stdata[pos+7],atom_len);
     1150                                    if (atom_len>10)
     1151                                        dprintf( "MOV: Vendor: %c%c%c%c H.263 level: %d H.263 profile: %d \n", trak->stdata[pos+8],trak->stdata[pos+9],trak->stdata[pos+10],trak->stdata[pos+11],trak->stdata[pos+12],trak->stdata[pos+13]);
     1152                                    break;
     1153                                case 0:
     1154                                    break;
     1155                                default:
     1156                                    dprintf( "MOV: Found unknown movie atom %c%c%c%c (%d)!\n",
     1157                                            trak->stdata[pos+4],trak->stdata[pos+5],trak->stdata[pos+6],trak->stdata[pos+7],
     1158                                            atom_len);
     1159                                }
     1160                                if(atom_len<8) break;
     1161                                pos+=atom_len;
     1162                                //                 printf("pos=%d max=%d\n",pos,trak->stdata_len);
     1163                            }
     1164                        }
     1165                        sh->fps=trak->timescale/
     1166                            ((trak->durmap_size>=1)?(float)trak->durmap[0].dur:1);
     1167                        sh->frametime=1.0f/sh->fps;
     1168
     1169                        sh->disp_w=trak->stdata[25]|(trak->stdata[24]<<8);
     1170                        sh->disp_h=trak->stdata[27]|(trak->stdata[26]<<8);
     1171                        // if image size is zero, fallback to display size
     1172                        if(!sh->disp_w && !sh->disp_h) {
     1173                            sh->disp_w=trak->tkdata[77]|(trak->tkdata[76]<<8);
     1174                            sh->disp_h=trak->tkdata[81]|(trak->tkdata[80]<<8);
     1175                        } else if(sh->disp_w!=(trak->tkdata[77]|(trak->tkdata[76]<<8))){
     1176                            // codec and display width differ... use display one for aspect
     1177                            sh->aspect=trak->tkdata[77]|(trak->tkdata[76]<<8);
     1178                            sh->aspect/=trak->tkdata[81]|(trak->tkdata[80]<<8);
     1179                        }
     1180
     1181                        if(depth>32+8) printf("*** depth = 0x%X\n",depth);
     1182
     1183                        // palettized?
     1184                        gray = 0;
     1185                        if (depth > 32) { depth&=31; gray = 1; } // depth > 32 means grayscale
     1186                        if ((depth == 2) || (depth == 4) || (depth == 8))
     1187                            palette_count = (1 << depth);
     1188                        else
     1189                            palette_count = 0;
     1190
     1191                        // emulate BITMAPINFOHEADER:
     1192                        if (palette_count)
     1193                        {
     1194                            sh->bih=malloc(sizeof(BITMAPINFOHEADERw) + palette_count * 4);
     1195                            memset(sh->bih,0,sizeof(BITMAPINFOHEADERw) + palette_count * 4);
     1196                            sh->bih->biSize=40 + palette_count * 4;
     1197                            // fetch the relevant fields
     1198                            flag = BE_16(&trak->stdata[hdr_ptr]);
     1199                            hdr_ptr += 2;
     1200                            start = BE_32(&trak->stdata[hdr_ptr]);
     1201                            hdr_ptr += 4;
     1202                            count_flag = BE_16(&trak->stdata[hdr_ptr]);
     1203                            hdr_ptr += 2;
     1204                            end = BE_16(&trak->stdata[hdr_ptr]);
     1205                            hdr_ptr += 2;
     1206                            palette_map = (unsigned char *)sh->bih + 40;
     1207                            dprintf( "Allocated %d entries for palette\n",
     1208                                    palette_count);
     1209                            dprintf( "QT palette: start: %x, end: %x, count flag: %d, flags: %x\n",
     1210                                    start, end, count_flag, flag);
     1211
     1212                            /* XXX: problems with sample (statunit6.mov) with flag&0x4 set! - alex*/
     1213
     1214                            // load default palette
     1215                            if (flag & 0x08)
     1216                            {
     1217                                if (gray)
     1218                                {
     1219                                    dprintf( "Using default QT grayscale palette\n");
     1220                                    if (palette_count == 16)
     1221                                        memcpy(palette_map, qt_default_grayscale_palette_16, 16 * 4);
     1222                                    else if (palette_count == 256) {
     1223                                        memcpy(palette_map, qt_default_grayscale_palette_256, 256 * 4);
     1224                                        if (trak->fourcc == mmioFOURCC('c','v','i','d')) {
     1225                                            int i;
     1226                                            // Hack for grayscale CVID, negative palette
     1227                                            // If you have samples where this is not required contact me (rxt)
     1228                                            dprintf( "MOV: greyscale cvid with default palette,"
     1229                                                    " enabling negative palette hack.\n");
     1230                                            for (i = 0; i < 256 * 4; i++)
     1231                                                palette_map[i] = palette_map[i] ^ 0xff;
     1232                                        }
     1233                                    }
     1234                                }
     1235                                else
     1236                                {
     1237                                    dprintf( "Using default QT colour palette\n");
     1238                                    if (palette_count == 4)
     1239                                        memcpy(palette_map, qt_default_palette_4, 4 * 4);
     1240                                    else if (palette_count == 16)
     1241                                        memcpy(palette_map, qt_default_palette_16, 16 * 4);
     1242                                    else if (palette_count == 256)
     1243                                        memcpy(palette_map, qt_default_palette_256, 256 * 4);
     1244                                }
     1245                            }
     1246                            // load palette from file
     1247                            else
     1248                            {
     1249                                dprintf( "Loading palette from file\n");
     1250                                for (i = start; i <= end; i++)
     1251                                {
     1252                                    entry = BE_16(&trak->stdata[hdr_ptr]);
     1253                                    hdr_ptr += 2;
     1254                                    // apparently, if count_flag is set, entry is same as i
     1255                                    if (count_flag & 0x8000)
     1256                                        entry = i;
     1257                                    // only care about top 8 bits of 16-bit R, G, or B value
     1258                                    if (entry <= palette_count && entry >= 0)
     1259                                    {
     1260                                        palette_map[entry * 4 + 2] = trak->stdata[hdr_ptr + 0];
     1261                                        palette_map[entry * 4 + 1] = trak->stdata[hdr_ptr + 2];
     1262                                        palette_map[entry * 4 + 0] = trak->stdata[hdr_ptr + 4];
     1263                                        dprintf("QT palette: added entry: %d of %d (colors: R:%x G:%x B:%x)\n",
     1264                                                entry, palette_count,
     1265                                                palette_map[entry * 4 + 2],
     1266                                                palette_map[entry * 4 + 1],
     1267                                                palette_map[entry * 4 + 0]);
     1268                                    }
     1269                                    else
     1270                                        dprintf( "QT palette: skipped entry (out of count): %d of %d\n",
     1271                                                entry, palette_count);
     1272                                    hdr_ptr += 6;
    7951273                                }
    7961274                            }
    7971275                        }
     1276                        else
     1277                        {
     1278                            if (trak->fourcc == mmioFOURCC('a','v','c','1')) {
     1279                                if (trak->stream_header_len > 0xffffffff - sizeof(BITMAPINFOHEADERw)) {
     1280                                    dprintf("Invalid extradata size %d, skipping\n");
     1281                                    trak->stream_header_len = 0;
     1282                                }
     1283
     1284                                sh->bih=malloc(sizeof(BITMAPINFOHEADERw) + trak->stream_header_len);
     1285                                memset(sh->bih,0,sizeof(BITMAPINFOHEADERw) + trak->stream_header_len);
     1286                                sh->bih->biSize=40  + trak->stream_header_len;
     1287                                memcpy(((unsigned char *)sh->bih)+40,  trak->stream_header, trak->stream_header_len);
     1288                                free (trak->stream_header);
     1289                                trak->stream_header_len = 0;
     1290                                trak->stream_header = NULL;
     1291                            } else {
     1292                                sh->bih=malloc(sizeof(BITMAPINFOHEADERw));
     1293                                memset(sh->bih,0,sizeof(BITMAPINFOHEADERw));
     1294                                sh->bih->biSize=40;
     1295                            }
     1296                        }
     1297                        sh->bih->biWidth=sh->disp_w;
     1298                        sh->bih->biHeight=sh->disp_h;
     1299                        sh->bih->biPlanes=0;
     1300                        sh->bih->biBitCount=depth;
     1301                        sh->bih->biCompression=trak->fourcc;
     1302                        sh->bih->biSizeImage=sh->bih->biWidth*sh->bih->biHeight;
     1303
     1304                        dprintf( "Image size: %d x %d (%d bpp)\n",sh->disp_w,sh->disp_h,sh->bih->biBitCount);
     1305                        if(trak->tkdata_len>81)
     1306                            dprintf( "Display size: %d x %d\n",
     1307                                    trak->tkdata[77]|(trak->tkdata[76]<<8),
     1308                                    trak->tkdata[81]|(trak->tkdata[80]<<8));
     1309                        dprintf( "Fourcc: %.4s  Codec: '%.*s'\n",(char *)&trak->fourcc,trak->stdata[42]&31,trak->stdata+43);
     1310
     1311                        //              if(demuxer->video->id==-1 || demuxer->video->id==priv->track_db){
     1312                        //                  // (auto)selected video track:
     1313                        //                  demuxer->video->id=priv->track_db;
     1314                        //                  demuxer->video->sh=sh; sh->ds=demuxer->video;
     1315                        //              }
     1316                        break;
    7981317                    }
    799 
    800                     switch (version) {
    801                     case 0:
    802                         adjust =  0; break;
    803                     case 1:
    804                         adjust = 48; break;
    805                     case 2:
    806                         adjust = 68; break;
     1318                    case MOV_TRAK_GENERIC:
     1319                        if (trak->fourcc == mmioFOURCC('m','p','4','s') ||
     1320                            trak->fourcc == mmioFOURCC('t','x','3','g') ||
     1321                            trak->fourcc == mmioFOURCC('t','e','x','t')) {
     1322                            sh_sub_t *sh = new_sh_sub(demuxer, priv->track_db);
     1323                            if (trak->fourcc == mmioFOURCC('m','p','4','s'))
     1324                                init_vobsub(sh, trak);
     1325                            else
     1326                                sh->type = 't';
     1327                        } else
     1328                            dprintf("Generic track - not completely understood! (id: %d)\n",
     1329                                    trak->id);
     1330                        /* XXX: Also this contains the FLASH data */
     1331#if 0
     1332                        {
     1333                            int pos = stream_tell(demuxer->stream);
     1334                            int i;
     1335                            int fd;
     1336                            char name[20];
     1337
     1338                            for (i=0; i<trak->samples_size; i++)
     1339                            {
     1340                                char buf[trak->samples[i].size];
     1341                                stream_seek(demuxer->stream, trak->samples[i].pos);
     1342                                snprintf((char *)&name[0], 20, "samp%d", i);
     1343                                fd = open((char *)&name[0], O_CREAT|O_WRONLY);
     1344                                stream_read(demuxer->stream, &buf[0], trak->samples[i].size);
     1345                                write(fd, &buf[0], trak->samples[i].size);
     1346                                close(fd);
     1347                            }
     1348                            for (i=0; i<trak->chunks_size; i++)
     1349                            {
     1350                                char buf[trak->length];
     1351                                stream_seek(demuxer->stream, trak->chunks[i].pos);
     1352                                snprintf((char *)&name[0], 20, "chunk%d", i);
     1353                                fd = open((char *)&name[0], O_CREAT|O_WRONLY);
     1354                                stream_read(demuxer->stream, &buf[0], trak->length);
     1355                                write(fd, &buf[0], trak->length);
     1356                                close(fd);
     1357                            }
     1358                            if (trak->samplesize > 0)
     1359                            {
     1360                                char *buf;
     1361
     1362                                buf = malloc(trak->samplesize);
     1363                                stream_seek(demuxer->stream, trak->chunks[0].pos);
     1364                                snprintf((char *)&name[0], 20, "trak%d", trak->id);
     1365                                fd = open((char *)&name[0], O_CREAT|O_WRONLY);
     1366                                stream_read(demuxer->stream, buf, trak->samplesize);
     1367                                write(fd, buf, trak->samplesize);
     1368                                close(fd);
     1369                            }
     1370                            stream_seek(demuxer->stream, pos);
     1371                        }
     1372#endif
     1373                        break;
    8071374                    default:
    808                         dprintf( "MOV: unknown sound atom version (%d); may not work!\n", version);
    809                         adjust = 68;
     1375                        dprintf( "Unknown track type found (type: %d)\n", trak->type);
     1376                        break;
    8101377                    }
    811                     if (trak->stdata_len >= 36 + adjust) {
    812                         int atom_len = char2int(trak->stdata,28+adjust);
    813                         switch(char2int(trak->stdata,32+adjust)) { // atom type
    814                         case MOV_FOURCC('e','s','d','s'): {
    815                             dprintf( "MOV: Found MPEG4 audio Elementary Stream Descriptor atom (%d)!\n", atom_len);
    816                             if(atom_len > 8) {
    817                                 esds_t esds;
    818                                 if(!mp4_parse_esds(&trak->stdata[36+adjust], atom_len-8, &esds)) {
    819                                     /* 0xdd is a "user private" id, not an official allocated id (see http://www.mp4ra.org/object.html),
    820                                      so perform some extra checks to be sure that this is really vorbis audio */
    821                                     if(esds.objectTypeId==0xdd && esds.streamType==0x15 && sh->format==0x6134706D && esds.decoderConfigLen > 8)
    822                                     {
    823                                         //vorbis audio
    824                                         unsigned char *buf[3];
    825                                         unsigned short sizes[3];
    826                                         int offset, len, k;
    827                                         unsigned char *ptr = esds.decoderConfig;
    828 
    829                                         if(ptr[0] != 0 || ptr[1] != 30) goto quit_vorbis_block; //wrong extradata layout
    830 
    831                                         offset = len = 0;
    832                                         for(k = 0; k < 3; k++)
    833                                         {
    834                                             sizes[k] = (ptr[offset]<<8) | ptr[offset+1];
    835                                             len += sizes[k];
    836                                             offset += 2;
    837                                             if(offset + sizes[k] > esds.decoderConfigLen)
    838                                             {
    839                                                 dprintf("MOV: ERROR!, not enough vorbis extradata to read: offset = %d, k=%d, size=%d, len: %d\n", offset, k, sizes[k], esds.decoderConfigLen);
    840                                                 goto quit_vorbis_block;
    841                                             }
    842                                             buf[k] = malloc(sizes[k]);
    843                                             if(!buf[k]) goto quit_vorbis_block;
    844                                             memcpy(buf[k], &ptr[offset], sizes[k]);
    845                                             offset += sizes[k];
    846                                         }
    847 
    848                                         sh->codecdata_len = len + len/255 + 64;
    849                                         sh->codecdata = malloc(sh->codecdata_len);
    850                                         ptr = sh->codecdata;
    851 
    852                                         ptr[0] = 2;
    853                                         offset = 1;
    854                                         offset += store_ughvlc(&ptr[offset], sizes[0]);
    855                                         offset += store_ughvlc(&ptr[offset], sizes[1]);
    856                                         for(k = 0; k < 3; k++)
    857                                         {
    858                                             memcpy(&ptr[offset], buf[k], sizes[k]);
    859                                             offset += sizes[k];
    860                                         }
    861 
    862                                         sh->codecdata_len = offset;
    863                                         sh->codecdata = realloc(sh->codecdata, offset);
    864                                         dprintf("demux_mov, vorbis extradata size: %d\n", offset);
    865                                         is_vorbis = 1;
    866                                     quit_vorbis_block:
    867                                         sh->format = mmioFOURCC('v', 'r', 'b', 's');
    868                                     }
    869                                     sh->i_bps = esds.avgBitrate/8;
    870 
    871                                     //                      printf("######## audio format = %d ########\n",esds.objectTypeId);
    872                                     if(esds.objectTypeId==MP4OTI_MPEG1Audio || esds.objectTypeId==MP4OTI_MPEG2AudioPart3)
    873                                         sh->format=0x55; // .mp3
    874                                     if(esds.objectTypeId==MP4OTI_13kVoice) { // 13K Voice, defined by 3GPP2
    875                                         sh->format=mmioFOURCC('Q', 'c', 'l', 'p');
    876                                         trak->nchannels=sh->channels=1;
    877                                         trak->samplebytes=sh->samplesize=1;
    878                                     }
    879 
    880                                     // dump away the codec specific configuration for the AAC decoder
    881                                     if(esds.decoderConfigLen){
    882                                         if( (esds.decoderConfig[0]>>3) == 29 )
    883                                             sh->format = 0x1d61346d; // request multi-channel mp3 decoder
    884                                         if(!is_vorbis)
    885                                         {
    886                                             sh->codecdata_len = esds.decoderConfigLen;
    887                                             sh->codecdata = (unsigned char *)malloc(sh->codecdata_len);
    888                                             memcpy(sh->codecdata, esds.decoderConfig, sh->codecdata_len);
    889                                         }
    890                                     }
    891                                 }
    892                                 mp4_free_esds(&esds); // freeup esds mem
    893 #if 0
    894                                 { FILE* f=fopen("esds.dat","wb");
    895                                     fwrite(&trak->stdata[36],atom_len-8,1,f);
    896                                 fclose(f); }
    897 #endif
    898                             }
    899                         } break;
    900                         case MOV_FOURCC('a','l','a','c'): {
    901                             dprintf( "MOV: Found alac atom (%d)!\n", atom_len);
    902                             if(atom_len > 8) {
    903                                 // copy all the atom (not only payload) for lavc alac decoder
    904                                 sh->codecdata_len = atom_len;
    905                                 sh->codecdata = (unsigned char *)malloc(sh->codecdata_len);
    906                                 memcpy(sh->codecdata, &trak->stdata[28], sh->codecdata_len);
    907                             }
    908                         } break;
    909                         case MOV_FOURCC('d','a','m','r'):
    910                             dprintf( "MOV: Found AMR audio atom %c%c%c%c (%d)!\n", trak->stdata[32+adjust],trak->stdata[33+adjust],trak->stdata[34+adjust],trak->stdata[35+adjust], atom_len);
    911                             if (atom_len>14) {
    912                                 dprintf( "mov: vendor: %c%c%c%c Version: %d\n",trak->stdata[36+adjust],trak->stdata[37+adjust],trak->stdata[38+adjust], trak->stdata[39+adjust],trak->stdata[40+adjust]);
    913                                 dprintf( "MOV: Modes set: %02x%02x\n",trak->stdata[41+adjust],trak->stdata[42+adjust]);
    914                                 dprintf( "MOV: Mode change period: %d Frames per sample: %d\n",trak->stdata[43+adjust],trak->stdata[44+adjust]);
    915                             }
    916                             break;
    917                         default:
    918                             dprintf( "MOV: Found unknown audio atom %c%c%c%c (%d)!\n",
    919                                     trak->stdata[32+adjust],trak->stdata[33+adjust],trak->stdata[34+adjust],trak->stdata[35+adjust],
    920                                     atom_len);
    921                         }
    922                     }
    923                     dprintf( "Fourcc: %.4s\n",(char *)&trak->fourcc);
    924 #if 0
    925                     { FILE* f=fopen("stdata.dat","wb");
    926                         fwrite(trak->stdata,trak->stdata_len,1,f);
    927                     fclose(f); }
    928                     { FILE* f=fopen("tkdata.dat","wb");
    929                         fwrite(trak->tkdata,trak->tkdata_len,1,f);
    930                     fclose(f); }
    931 #endif
    932                     // Emulate WAVEFORMATEX struct:
    933                     sh->wf=malloc(sizeof(WAVEFORMATEX) + (is_vorbis ? sh->codecdata_len : 0));
    934                     memset(sh->wf,0,sizeof(WAVEFORMATEX));
    935                     sh->wf->nChannels=sh->channels;
    936                     sh->wf->wBitsPerSample=(trak->stdata[18]<<8)+trak->stdata[19];
    937                     // sh->wf->nSamplesPerSec=trak->timescale;
    938                     sh->wf->nSamplesPerSec=sh->samplerate;
    939                     if(trak->stdata_len >= 44 && trak->stdata[9]>=1 && char2int(trak->stdata,28)>0){
    940                         //Audio header: samp/pack=4096 bytes/pack=743 bytes/frame=1486 bytes/samp=2
    941                         sh->wf->nAvgBytesPerSec=(sh->wf->nChannels*sh->wf->nSamplesPerSec*
    942                                                  char2int(trak->stdata,32)+char2int(trak->stdata,28)/2)
    943                             /char2int(trak->stdata,28);
    944                         sh->wf->nBlockAlign=char2int(trak->stdata,36);
    945                     } else {
    946                         sh->wf->nAvgBytesPerSec=sh->wf->nChannels*sh->wf->wBitsPerSample*sh->wf->nSamplesPerSec/8;
    947                         // workaround for ms11 ima4
    948                         if (sh->format == 0x1100736d && trak->stdata_len >= 36)
    949                             sh->wf->nBlockAlign=char2int(trak->stdata,36);
    950                     }
    951                     if(is_vorbis && sh->codecdata_len)
    952                     {
    953                         memcpy(sh->wf+1, sh->codecdata, sh->codecdata_len);
    954                         sh->wf->cbSize = sh->codecdata_len;
    955                     }
    956                     // Selection:
    957                     //          if(demuxer->audio->id==-1 || demuxer->audio->id==priv->track_db){
    958                     //              // (auto)selected audio track:
    959                     //              demuxer->audio->id=priv->track_db;
    960                     //              demuxer->audio->sh=sh; sh->ds=demuxer->audio;
    961                     //          }
     1378                    dprintf( "--------------\n");
     1379                    priv->track_db++;
     1380                    trak=NULL;
    9621381                    break;
    9631382                }
    964                 case MOV_TRAK_VIDEO: {
    965                     int i, entry;
    966                     int flag, start, count_flag, end, palette_count, gray;
    967                     int hdr_ptr = 76;  // the byte just after depth
    968                     unsigned char *palette_map;
    969                     sh_video_t* sh=new_sh_video(demuxer,priv->track_db);
    970                     int depth;
    971                     sh->format=trak->fourcc;
    972 
    973                     // crude video delay from editlist0 hack ::atm
    974                     if(trak->editlist_size>=1) {
    975                         if(trak->editlist[0].pos == -1) {
    976                             sh->stream_delay = (float)trak->editlist[0].dur/(float)priv->timescale;
    977                             dprintf("MOV: Initial Video-Delay: %.3f sec\n", sh->stream_delay);
    978                         }
    979                     }
    980 
    981                     if (trak->stdata_len < 78) {
    982                         dprintf("MOV: Invalid (%d bytes instead of >= 78) video trak desc\n",
    983                                 trak->stdata_len);
     1383#ifndef HAVE_ZLIB
     1384                case MOV_FOURCC('c','m','o','v'): {
     1385                    dprintf("MOV: got compressed header but have no zlib\n");
     1386                    return;
     1387                }
     1388#else
     1389                case MOV_FOURCC('m','o','o','v'):
     1390                case MOV_FOURCC('c','m','o','v'): {
     1391                    //      dprintf(MSGTR_MOVcomprhdr);
     1392                    lschunks(demuxer,level+1,pos+len,NULL);
     1393                    break;
     1394                }
     1395                case MOV_FOURCC('d','c','o','m'): {
     1396                    //      int temp=stream_read_dword(demuxer->stream);
     1397                    unsigned int algo=be2me_32(stream_read_dword(demuxer->stream));
     1398                    dprintf( "Compressed header uses %.4s algo!\n",(char *)&algo);
     1399                    break;
     1400                }
     1401                case MOV_FOURCC('c','m','v','d'): {
     1402                    //      int temp=stream_read_dword(demuxer->stream);
     1403                    unsigned int moov_sz=stream_read_dword(demuxer->stream);
     1404                    unsigned int cmov_sz=len-4;
     1405                    unsigned char* cmov_buf;
     1406                    unsigned char* moov_buf;
     1407                    int zret;
     1408                    z_stream zstrm;
     1409                    stream_t* backup;
     1410
     1411                    if (moov_sz > 0xffffffff - 16) {
     1412                        dprintf("Invalid cmvd atom size %d\n", moov_sz);
    9841413                        break;
    9851414                    }
    986                     depth = trak->stdata[75] | (trak->stdata[74] << 8);
    987                     //  stdata[]:
    988                     //  8   short       version
    989                     //  10  short       revision
    990                     //  12  int         vendor_id
    991                     //  16  int         temporal_quality
    992                     //  20  int         spatial_quality
    993                     //  24  short       width
    994                     //  26  short       height
    995                     //  28  int         h_dpi
    996                     //  32  int         v_dpi
    997                     //  36  int         0
    998                     //  40  short       frames_per_sample
    999                     //  42  char[4]     compressor_name
    1000                     //  74  short       depth
    1001                     //  76  short       color_table_id
    1002                     // additional atoms may follow,
    1003                     // eg esds atom from .MP4 files
    1004                     //      78  int             atom size
    1005                     //      82  char[4] atom type
    1006                     //  86  ...         atom data
    1007 
    1008                     {   ImageDescription* id=malloc(8+trak->stdata_len);  // safe
    1009                         trak->desc=id;
    1010                     id->idSize=8+trak->stdata_len;
    1011                     //          id->cType=bswap_32(trak->fourcc);
    1012                     id->cType=le2me_32(trak->fourcc);
    1013                     id->version=char2short(trak->stdata,8);
    1014                     id->revisionLevel=char2short(trak->stdata,10);
    1015                     id->vendor=char2int(trak->stdata,12);
    1016                     id->temporalQuality=char2int(trak->stdata,16);
    1017                     id->spatialQuality=char2int(trak->stdata,20);
    1018                     id->width=char2short(trak->stdata,24);
    1019                     id->height=char2short(trak->stdata,26);
    1020                     id->hRes=char2int(trak->stdata,28);
    1021                     id->vRes=char2int(trak->stdata,32);
    1022                     id->dataSize=char2int(trak->stdata,36);
    1023                     id->frameCount=char2short(trak->stdata,40);
    1024                     memcpy(&id->name,trak->stdata+42,32);
    1025                     id->depth=char2short(trak->stdata,74);
    1026                     id->clutID=char2short(trak->stdata,76);
    1027                     if(trak->stdata_len>78)     memcpy(((char*)&id->clutID)+2,trak->stdata+78,trak->stdata_len-78);
    1028                     sh->ImageDesc=id;
     1415                    cmov_buf=malloc(cmov_sz);
     1416                    moov_buf=malloc(moov_sz+16);
     1417                    dprintf( "Compressed header size: %d / %d\n",cmov_sz,moov_sz);
     1418
     1419                    stream_read(demuxer->stream,cmov_buf,cmov_sz);
     1420
     1421                    zstrm.zalloc          = (alloc_func)0;
     1422                    zstrm.zfree           = (free_func)0;
     1423                    zstrm.opaque          = (voidpf)0;
     1424                    zstrm.next_in         = cmov_buf;
     1425                    zstrm.avail_in        = cmov_sz;
     1426                    zstrm.next_out        = moov_buf;
     1427                    zstrm.avail_out       = moov_sz;
     1428
     1429                    zret = inflateInit(&zstrm);
     1430                    if (zret != Z_OK)
     1431                    { dprintf( "QT cmov: inflateInit err %d\n",zret);
     1432                        return;
     1433                    }
     1434                    zret = inflate(&zstrm, Z_NO_FLUSH);
     1435                    if ((zret != Z_OK) && (zret != Z_STREAM_END))
     1436                    { dprintf( "QT cmov inflate: ERR %d\n",zret);
     1437                        return;
     1438                    }
    10291439#if 0
    1030                     {   FILE *f=fopen("ImageDescription","wb");
    1031                         fwrite(id,id->idSize,1,f);
    1032                     fclose(f);
     1440                    else {
     1441                        FILE *DecOut;
     1442                        DecOut = fopen("Out.bin", "w");
     1443                        fwrite(moov_buf, 1, moov_sz, DecOut);
     1444                        fclose(DecOut);
    10331445                    }
    10341446#endif
    1035                     }
    1036 
    1037                     if(trak->stdata_len >= 86) { // extra atoms found
    1038                         int pos=78;
    1039                         int atom_len;
    1040                         while(pos+8<=trak->stdata_len &&
    1041                               (pos+(atom_len=char2int(trak->stdata,pos)))<=trak->stdata_len){
    1042                             switch(char2int(trak->stdata,pos+4)) { // switch atom type
    1043                             case MOV_FOURCC('g','a','m','a'):
    1044                                 // intfp with gamma value at which movie was captured
    1045                                 // can be used to gamma correct movie display
    1046                                 dprintf( "MOV: Found unsupported Gamma-Correction movie atom (%d)!\n",
    1047                                         atom_len);
    1048                                 break;
    1049                             case MOV_FOURCC('f','i','e','l'):
    1050                                 // 2 char-values (8bit int) that specify field handling
    1051                                 // see the Apple's QuickTime Fileformat PDF for more info
    1052                                 dprintf( "MOV: Found unsupported Field-Handling movie atom (%d)!\n",
    1053                                         atom_len);
    1054                                 break;
    1055                             case MOV_FOURCC('m','j','q','t'):
    1056                                 // Motion-JPEG default quantization table
    1057                                 dprintf( "MOV: Found unsupported MJPEG-Quantization movie atom (%d)!\n",
    1058                                         atom_len);
    1059                                 break;
    1060                             case MOV_FOURCC('m','j','h','t'):
    1061                                 // Motion-JPEG default huffman table
    1062                                 dprintf( "MOV: Found unsupported MJPEG-Huffman movie atom (%d)!\n",
    1063                                         atom_len);
    1064                                 break;
    1065                             case MOV_FOURCC('e','s','d','s'):
    1066                                 // MPEG4 Elementary Stream Descriptor header
    1067                                 dprintf( "MOV: Found MPEG4 movie Elementary Stream Descriptor atom (%d)!\n", atom_len);
    1068                                 // add code here to save esds header of length atom_len-8
    1069                                 // beginning at stdata[86] to some variable to pass it
    1070                                 // on to the decoder ::atmos
    1071                                 if(atom_len > 8) {
    1072                                     esds_t esds;
    1073                                     if(!mp4_parse_esds(trak->stdata+pos+8, atom_len-8, &esds)) {
    1074 
    1075                                         if(esds.objectTypeId==MP4OTI_MPEG2VisualSimple || esds.objectTypeId==MP4OTI_MPEG2VisualMain ||
    1076                                            esds.objectTypeId==MP4OTI_MPEG2VisualSNR || esds.objectTypeId==MP4OTI_MPEG2VisualSpatial ||
    1077                                            esds.objectTypeId==MP4OTI_MPEG2VisualHigh || esds.objectTypeId==MP4OTI_MPEG2Visual422)
    1078                                             sh->format=mmioFOURCC('m', 'p', 'g', '2');
    1079                                         else if(esds.objectTypeId==MP4OTI_MPEG1Visual)
    1080                                             sh->format=mmioFOURCC('m', 'p', 'g', '1');
    1081 
    1082                                         // dump away the codec specific configuration for the AAC decoder
    1083                                         trak->stream_header_len = esds.decoderConfigLen;
    1084                                         trak->stream_header = (unsigned char *)malloc(trak->stream_header_len);
    1085                                         memcpy(trak->stream_header, esds.decoderConfig, trak->stream_header_len);
     1447                    if(moov_sz != zstrm.total_out)
     1448                        dprintf( "Warning! moov size differs cmov: %d  zlib: %ld\n",moov_sz,zstrm.total_out);
     1449                    zret = inflateEnd(&zstrm);
     1450
     1451                    backup=demuxer->stream;
     1452                    demuxer->stream=new_memory_stream(moov_buf,moov_sz);
     1453                    stream_skip(demuxer->stream,8);
     1454                    lschunks(demuxer,level+1,moov_sz,NULL); // parse uncompr. 'moov'
     1455                    //free_stream(demuxer->stream);
     1456                    demuxer->stream=backup;
     1457                    free(cmov_buf);
     1458                    free(moov_buf);
     1459                    break;
     1460                }
     1461#endif
     1462                case MOV_FOURCC('u','d','t','a'):
     1463                    {
     1464                        unsigned int udta_id;
     1465                        off_t udta_len;
     1466                        off_t udta_size = len;
     1467
     1468                        dprintf( "mov: user data record found\n");
     1469                        dprintf( "Quicktime Clip Info:\n");
     1470
     1471                        while((len > 8) && (udta_size > 8))
     1472                        {
     1473                            udta_len = stream_read_dword(demuxer->stream);
     1474                            udta_id = stream_read_dword(demuxer->stream);
     1475                            udta_size -= 8;
     1476                            dprintf( "udta_id: %.4s (len: %"PRId64")\n", (char *)&udta_id, (int64_t)udta_len);
     1477                            switch (udta_id)
     1478                            {
     1479                            case MOV_FOURCC(0xa9,'c','p','y'):
     1480                            case MOV_FOURCC(0xa9,'d','a','y'):
     1481                            case MOV_FOURCC(0xa9,'d','i','r'):
     1482                                /* 0xa9,'e','d','1' - '9' : edit timestamps */
     1483                            case MOV_FOURCC(0xa9,'f','m','t'):
     1484                            case MOV_FOURCC(0xa9,'i','n','f'):
     1485                            case MOV_FOURCC(0xa9,'p','r','d'):
     1486                            case MOV_FOURCC(0xa9,'p','r','f'):
     1487                            case MOV_FOURCC(0xa9,'r','e','q'):
     1488                            case MOV_FOURCC(0xa9,'s','r','c'):
     1489                            case MOV_FOURCC('n','a','m','e'):
     1490                            case MOV_FOURCC(0xa9,'n','a','m'):
     1491                            case MOV_FOURCC(0xa9,'A','R','T'):
     1492                            case MOV_FOURCC(0xa9,'c','m','t'):
     1493                            case MOV_FOURCC(0xa9,'a','u','t'):
     1494                            case MOV_FOURCC(0xa9,'s','w','r'):
     1495                                {
     1496                                    off_t text_len = stream_read_word(demuxer->stream);
     1497                                    char text[text_len+2+1];
     1498                                    stream_read(demuxer->stream, (char *)&text, text_len+2);
     1499                                    text[text_len+2] = 0x0;
     1500                                    switch(udta_id)
     1501                                    {
     1502                                    case MOV_FOURCC(0xa9,'a','u','t'):
     1503                                        demux_info_add(demuxer, "author", &text[2]);
     1504                                        dprintf( " Author: %s\n", &text[2]);
     1505                                        break;
     1506                                    case MOV_FOURCC(0xa9,'c','p','y'):
     1507                                        demux_info_add(demuxer, "copyright", &text[2]);
     1508                                        dprintf( " Copyright: %s\n", &text[2]);
     1509                                        break;
     1510                                    case MOV_FOURCC(0xa9,'i','n','f'):
     1511                                        dprintf( " Info: %s\n", &text[2]);
     1512                                        break;
     1513                                    case MOV_FOURCC('n','a','m','e'):
     1514                                    case MOV_FOURCC(0xa9,'n','a','m'):
     1515                                        demux_info_add(demuxer, "name", &text[2]);
     1516                                        dprintf( " Name: %s\n", &text[2]);
     1517                                        break;
     1518                                    case MOV_FOURCC(0xa9,'A','R','T'):
     1519                                        dprintf( " Artist: %s\n", &text[2]);
     1520                                        break;
     1521                                    case MOV_FOURCC(0xa9,'d','i','r'):
     1522                                        dprintf( " Director: %s\n", &text[2]);
     1523                                        break;
     1524                                    case MOV_FOURCC(0xa9,'c','m','t'):
     1525                                        demux_info_add(demuxer, "comments", &text[2]);
     1526                                        dprintf( " Comment: %s\n", &text[2]);
     1527                                        break;
     1528                                    case MOV_FOURCC(0xa9,'r','e','q'):
     1529                                        dprintf( " Requirements: %s\n", &text[2]);
     1530                                        break;
     1531                                    case MOV_FOURCC(0xa9,'s','w','r'):
     1532                                        demux_info_add(demuxer, "encoder", &text[2]);
     1533                                        dprintf( " Software: %s\n", &text[2]);
     1534                                        break;
     1535                                    case MOV_FOURCC(0xa9,'d','a','y'):
     1536                                        dprintf( " Creation timestamp: %s\n", &text[2]);
     1537                                        break;
     1538                                    case MOV_FOURCC(0xa9,'f','m','t'):
     1539                                        dprintf( " Format: %s\n", &text[2]);
     1540                                        break;
     1541                                    case MOV_FOURCC(0xa9,'p','r','d'):
     1542                                        dprintf( " Producer: %s\n", &text[2]);
     1543                                        break;
     1544                                    case MOV_FOURCC(0xa9,'p','r','f'):
     1545                                        dprintf( " Performer(s): %s\n", &text[2]);
     1546                                        break;
     1547                                    case MOV_FOURCC(0xa9,'s','r','c'):
     1548                                        dprintf( " Source providers: %s\n", &text[2]);
     1549                                        break;
    10861550                                    }
    1087                                     mp4_free_esds(&esds); // freeup esds mem
     1551                                    udta_size -= 4+text_len;
     1552                                    break;
    10881553                                }
    1089                                 break;
    1090                             case MOV_FOURCC('a','v','c','C'):
    1091                                 // AVC decoder configuration record
    1092                                 dprintf( "MOV: AVC decoder configuration record atom (%d)!\n", atom_len);
    1093                                 if(atom_len > 8) {
    1094                                     int i, poffs, cnt;
    1095                                     // Parse some parts of avcC, just for fun :)
    1096                                     // real parsing is done by avc1 decoder
    1097                                     dprintf( "MOV: avcC version: %d\n", *(trak->stdata+pos+8));
    1098                                     if (*(trak->stdata+pos+8) != 1)
    1099                                         dprintf( "MOV: unknown avcC version (%d). Expexct problems.\n", *(trak->stdata+pos+9));
    1100                                     dprintf( "MOV: avcC profile: %d\n", *(trak->stdata+pos+9));
    1101                                     dprintf( "MOV: avcC profile compatibility: %d\n", *(trak->stdata+pos+10));
    1102                                     dprintf( "MOV: avcC level: %d\n", *(trak->stdata+pos+11));
    1103                                     dprintf( "MOV: avcC nal length size: %d\n", ((*(trak->stdata+pos+12))&0x03)+1);
    1104                                     dprintf( "MOV: avcC number of sequence param sets: %d\n", cnt = (*(trak->stdata+pos+13) & 0x1f));
    1105                                     poffs = pos + 14;
    1106                                     for (i = 0; i < cnt; i++) {
    1107                                         dprintf( "MOV: avcC sps %d have length %d\n", i, BE_16(trak->stdata+poffs));
    1108                                         poffs += BE_16(trak->stdata+poffs) + 2;
    1109                                     }
    1110                                     dprintf( "MOV: avcC number of picture param sets: %d\n", *(trak->stdata+poffs));
    1111                                     poffs++;
    1112                                     for (i = 0; i < cnt; i++) {
    1113                                         dprintf( "MOV: avcC pps %d have length %d\n", i, BE_16(trak->stdata+poffs));
    1114                                         poffs += BE_16(trak->stdata+poffs) + 2;
    1115                                     }
    1116                                     // Copy avcC for the AVC decoder
    1117                                     // This data will be put in extradata below, where BITMAPINFOHEADER is created
    1118                                     trak->stream_header_len = atom_len-8;
    1119                                     trak->stream_header = (unsigned char *)malloc(trak->stream_header_len);
    1120                                     memcpy(trak->stream_header, trak->stdata+pos+8, trak->stream_header_len);
    1121                                 }
    1122                                 break;
    1123                             case MOV_FOURCC('d','2','6','3'):
    1124                                 dprintf( "MOV: Found H.263 decoder atom %c%c%c%c (%d)!\n", trak->stdata[pos+4],trak->stdata[pos+5],trak->stdata[pos+6],trak->stdata[pos+7],atom_len);
    1125                                 if (atom_len>10)
    1126                                     dprintf( "MOV: Vendor: %c%c%c%c H.263 level: %d H.263 profile: %d \n", trak->stdata[pos+8],trak->stdata[pos+9],trak->stdata[pos+10],trak->stdata[pos+11],trak->stdata[pos+12],trak->stdata[pos+13]);
    1127                                 break;
    1128                             case 0:
    1129                                 break;
     1554                                /* some other shits:    WLOC - window location,
     1555                                 LOOP - looping style,
     1556                                 SelO - play only selected frames
     1557                                 AllF - play all frames
     1558                                 */
     1559                            case MOV_FOURCC('W','L','O','C'):
     1560                            case MOV_FOURCC('L','O','O','P'):
     1561                            case MOV_FOURCC('S','e','l','O'):
     1562                            case MOV_FOURCC('A','l','l','F'):
    11301563                            default:
    1131                                 dprintf( "MOV: Found unknown movie atom %c%c%c%c (%d)!\n",
    1132                                         trak->stdata[pos+4],trak->stdata[pos+5],trak->stdata[pos+6],trak->stdata[pos+7],
    1133                                         atom_len);
    1134                             }
    1135                             if(atom_len<8) break;
    1136                             pos+=atom_len;
    1137                             //             printf("pos=%d max=%d\n",pos,trak->stdata_len);
    1138                         }
    1139                     }
    1140                     sh->fps=trak->timescale/
    1141                         ((trak->durmap_size>=1)?(float)trak->durmap[0].dur:1);
    1142                     sh->frametime=1.0f/sh->fps;
    1143 
    1144                     sh->disp_w=trak->stdata[25]|(trak->stdata[24]<<8);
    1145                     sh->disp_h=trak->stdata[27]|(trak->stdata[26]<<8);
    1146                     // if image size is zero, fallback to display size
    1147                     if(!sh->disp_w && !sh->disp_h) {
    1148                         sh->disp_w=trak->tkdata[77]|(trak->tkdata[76]<<8);
    1149                         sh->disp_h=trak->tkdata[81]|(trak->tkdata[80]<<8);
    1150                     } else if(sh->disp_w!=(trak->tkdata[77]|(trak->tkdata[76]<<8))){
    1151                         // codec and display width differ... use display one for aspect
    1152                         sh->aspect=trak->tkdata[77]|(trak->tkdata[76]<<8);
    1153                         sh->aspect/=trak->tkdata[81]|(trak->tkdata[80]<<8);
    1154                     }
    1155 
    1156                     if(depth>32+8) printf("*** depth = 0x%X\n",depth);
    1157 
    1158                     // palettized?
    1159                     gray = 0;
    1160                     if (depth > 32) { depth&=31; gray = 1; } // depth > 32 means grayscale
    1161                     if ((depth == 2) || (depth == 4) || (depth == 8))
    1162                         palette_count = (1 << depth);
    1163                     else
    1164                         palette_count = 0;
    1165 
    1166                     // emulate BITMAPINFOHEADER:
    1167                     if (palette_count)
    1168                     {
    1169                         sh->bih=malloc(sizeof(BITMAPINFOHEADERw) + palette_count * 4);
    1170                         memset(sh->bih,0,sizeof(BITMAPINFOHEADERw) + palette_count * 4);
    1171                         sh->bih->biSize=40 + palette_count * 4;
    1172                         // fetch the relevant fields
    1173                         flag = BE_16(&trak->stdata[hdr_ptr]);
    1174                         hdr_ptr += 2;
    1175                         start = BE_32(&trak->stdata[hdr_ptr]);
    1176                         hdr_ptr += 4;
    1177                         count_flag = BE_16(&trak->stdata[hdr_ptr]);
    1178                         hdr_ptr += 2;
    1179                         end = BE_16(&trak->stdata[hdr_ptr]);
    1180                         hdr_ptr += 2;
    1181                         palette_map = (unsigned char *)sh->bih + 40;
    1182                         dprintf( "Allocated %d entries for palette\n",
    1183                                 palette_count);
    1184                         dprintf( "QT palette: start: %x, end: %x, count flag: %d, flags: %x\n",
    1185                                 start, end, count_flag, flag);
    1186 
    1187                         /* XXX: problems with sample (statunit6.mov) with flag&0x4 set! - alex*/
    1188 
    1189                         // load default palette
    1190                         if (flag & 0x08)
    1191                         {
    1192                             if (gray)
    1193                             {
    1194                                 dprintf( "Using default QT grayscale palette\n");
    1195                                 if (palette_count == 16)
    1196                                     memcpy(palette_map, qt_default_grayscale_palette_16, 16 * 4);
    1197                                 else if (palette_count == 256) {
    1198                                     memcpy(palette_map, qt_default_grayscale_palette_256, 256 * 4);
    1199                                     if (trak->fourcc == mmioFOURCC('c','v','i','d')) {
    1200                                         int i;
    1201                                         // Hack for grayscale CVID, negative palette
    1202                                         // If you have samples where this is not required contact me (rxt)
    1203                                         dprintf( "MOV: greyscale cvid with default palette,"
    1204                                                 " enabling negative palette hack.\n");
    1205                                         for (i = 0; i < 256 * 4; i++)
    1206                                             palette_map[i] = palette_map[i] ^ 0xff;
     1564                                {
     1565                                    if( udta_len>udta_size)
     1566                                        udta_len=udta_size;
     1567                                    {
     1568                                        char dump[udta_len-4];
     1569                                        stream_read(demuxer->stream, (char *)&dump, udta_len-4-4);
     1570                                        udta_size -= udta_len;
    12071571                                    }
    12081572                                }
    12091573                            }
    1210                             else
    1211                             {
    1212                                 dprintf( "Using default QT colour palette\n");
    1213                                 if (palette_count == 4)
    1214                                     memcpy(palette_map, qt_default_palette_4, 4 * 4);
    1215                                 else if (palette_count == 16)
    1216                                     memcpy(palette_map, qt_default_palette_16, 16 * 4);
    1217                                 else if (palette_count == 256)
    1218                                     memcpy(palette_map, qt_default_palette_256, 256 * 4);
    1219                             }
    12201574                        }
    1221                         // load palette from file
    1222                         else
    1223                         {
    1224                             dprintf( "Loading palette from file\n");
    1225                             for (i = start; i <= end; i++)
    1226                             {
    1227                                 entry = BE_16(&trak->stdata[hdr_ptr]);
    1228                                 hdr_ptr += 2;
    1229                                 // apparently, if count_flag is set, entry is same as i
    1230                                 if (count_flag & 0x8000)
    1231                                     entry = i;
    1232                                 // only care about top 8 bits of 16-bit R, G, or B value
    1233                                 if (entry <= palette_count && entry >= 0)
    1234                                 {
    1235                                     palette_map[entry * 4 + 2] = trak->stdata[hdr_ptr + 0];
    1236                                     palette_map[entry * 4 + 1] = trak->stdata[hdr_ptr + 2];
    1237                                     palette_map[entry * 4 + 0] = trak->stdata[hdr_ptr + 4];
    1238                                     dprintf("QT palette: added entry: %d of %d (colors: R:%x G:%x B:%x)\n",
    1239                                             entry, palette_count,
    1240                                             palette_map[entry * 4 + 2],
    1241                                             palette_map[entry * 4 + 1],
    1242                                             palette_map[entry * 4 + 0]);
    1243                                 }
    1244                                 else
    1245                                     dprintf( "QT palette: skipped entry (out of count): %d of %d\n",
    1246                                             entry, palette_count);
    1247                                 hdr_ptr += 6;
    1248                             }
    1249                         }
    1250                     }
    1251                     else
    1252                     {
    1253                         if (trak->fourcc == mmioFOURCC('a','v','c','1')) {
    1254                             if (trak->stream_header_len > 0xffffffff - sizeof(BITMAPINFOHEADERw)) {
    1255                                 dprintf("Invalid extradata size %d, skipping\n");
    1256                                 trak->stream_header_len = 0;
    1257                             }
    1258 
    1259                             sh->bih=malloc(sizeof(BITMAPINFOHEADERw) + trak->stream_header_len);
    1260                             memset(sh->bih,0,sizeof(BITMAPINFOHEADERw) + trak->stream_header_len);
    1261                             sh->bih->biSize=40  + trak->stream_header_len;
    1262                             memcpy(((unsigned char *)sh->bih)+40,  trak->stream_header, trak->stream_header_len);
    1263                             free (trak->stream_header);
    1264                             trak->stream_header_len = 0;
    1265                             trak->stream_header = NULL;
    1266                         } else {
    1267                             sh->bih=malloc(sizeof(BITMAPINFOHEADERw));
    1268                             memset(sh->bih,0,sizeof(BITMAPINFOHEADERw));
    1269                             sh->bih->biSize=40;
    1270                         }
    1271                     }
    1272                     sh->bih->biWidth=sh->disp_w;
    1273                     sh->bih->biHeight=sh->disp_h;
    1274                     sh->bih->biPlanes=0;
    1275                     sh->bih->biBitCount=depth;
    1276                     sh->bih->biCompression=trak->fourcc;
    1277                     sh->bih->biSizeImage=sh->bih->biWidth*sh->bih->biHeight;
    1278 
    1279                     dprintf( "Image size: %d x %d (%d bpp)\n",sh->disp_w,sh->disp_h,sh->bih->biBitCount);
    1280                     if(trak->tkdata_len>81)
    1281                         dprintf( "Display size: %d x %d\n",
    1282                                 trak->tkdata[77]|(trak->tkdata[76]<<8),
    1283                                 trak->tkdata[81]|(trak->tkdata[80]<<8));
    1284                     dprintf( "Fourcc: %.4s  Codec: '%.*s'\n",(char *)&trak->fourcc,trak->stdata[42]&31,trak->stdata+43);
    1285 
    1286                     //          if(demuxer->video->id==-1 || demuxer->video->id==priv->track_db){
    1287                     //              // (auto)selected video track:
    1288                     //              demuxer->video->id=priv->track_db;
    1289                     //              demuxer->video->sh=sh; sh->ds=demuxer->video;
    1290                     //          }
     1575                        break;
     1576                    } /* eof udta */
     1577                default:
     1578                    id = be2me_32(id);
     1579                    dprintf("MOV: unknown chunk: %.4s %d\n",(char *)&id,(int)len);
     1580                } /* endof switch */
     1581            } /* endof else */
     1582
     1583            pos+=len+8;
     1584            if(pos>=endpos) break;
     1585            if(!stream_seek(demuxer->stream,pos)) break;
     1586        }
     1587    }
     1588
     1589    static int lschunks_intrak(demuxer_t* demuxer, int level, unsigned int id,
     1590                               off_t pos, off_t len, mov_track_t* trak)
     1591    {
     1592        switch(id) {
     1593        case MOV_FOURCC('m','d','a','t'): {
     1594            dprintf("Hmm, strange MOV, parsing mdat in lschunks?\n");
     1595            return -1;
     1596        }
     1597        case MOV_FOURCC('f','r','e','e'):
     1598        case MOV_FOURCC('u','d','t','a'):
     1599            /* here not supported :p */
     1600            break;
     1601        case MOV_FOURCC('t','k','h','d'): {
     1602            dprintf("MOV: %*sTrack header!\n", level, "");
     1603            // read codec data
     1604            trak->tkdata_len = len;
     1605            trak->tkdata = malloc(trak->tkdata_len);
     1606            stream_read(demuxer->stream, trak->tkdata, trak->tkdata_len);
     1607            /*
     1608             0  1 Version
     1609             1  3 Flags
     1610             4  4 Creation time
     1611             8  4 Modification time
     1612             12 4 Track ID
     1613             16 4 Reserved
     1614             20 4 Duration
     1615             24 8 Reserved
     1616             32 2 Layer
     1617             34 2 Alternate group
     1618             36 2 Volume
     1619             38 2 Reserved
     1620             40 36 Matrix structure
     1621             76 4 Track width
     1622             80 4 Track height
     1623             */
     1624            dprintf(
     1625                    "tkhd len=%d ver=%d flags=0x%X id=%d dur=%d lay=%d vol=%d\n",
     1626                    trak->tkdata_len, trak->tkdata[0], trak->tkdata[1],
     1627                    char2int(trak->tkdata, 12), // id
     1628                    char2int(trak->tkdata, 20), // duration
     1629                    char2short(trak->tkdata, 32), // layer
     1630                    char2short(trak->tkdata, 36)); // volume
     1631            break;
     1632        }
     1633        case MOV_FOURCC('m','d','h','d'): {
     1634            dprintf( "MOV: %*sMedia header!\n", level, "");
     1635            int version = stream_read_char(demuxer->stream);
     1636            stream_skip(demuxer->stream, (version == 1) ? 19 : 11);
     1637            // read timescale
     1638            trak->timescale = stream_read_dword(demuxer->stream);
     1639            // read length
     1640            if (version == 1)
     1641                trak->length = stream_read_qword(demuxer->stream);
     1642            else
     1643                trak->length = stream_read_dword(demuxer->stream);
     1644            break;
     1645        }
     1646        case MOV_FOURCC('h','d','l','r'): {
     1647            unsigned int tmp = stream_read_dword(demuxer->stream);
     1648            unsigned int type = stream_read_dword_le(demuxer->stream);
     1649            unsigned int subtype = stream_read_dword_le(demuxer->stream);
     1650            unsigned int manufact = stream_read_dword_le(demuxer->stream);
     1651            unsigned int comp_flags = stream_read_dword(demuxer->stream);
     1652            unsigned int comp_mask = stream_read_dword(demuxer->stream);
     1653            int len = stream_read_char(demuxer->stream);
     1654            char* str = malloc(len + 1);
     1655            stream_read(demuxer->stream, str, len);
     1656            str[len] = 0;
     1657            dprintf(
     1658                    "MOV: %*sHandler header: %.4s/%.4s (%.4s) %s\n", level, "",
     1659                    (char *)&type, (char *)&subtype, (char *)&manufact, str);
     1660            free(str);
     1661            switch(bswap_32(type)) {
     1662            case MOV_FOURCC('m','h','l','r'):
     1663                trak->media_handler = bswap_32(subtype);
     1664                break;
     1665            case MOV_FOURCC('d','h','l','r'):
     1666                trak->data_handler = bswap_32(subtype);
     1667                break;
     1668            default:
     1669                dprintf(
     1670                        "MOV: unknown handler class: 0x%X (%.4s)\n",
     1671                        bswap_32(type), (char *)&type);
     1672            }
     1673            break;
     1674        }
     1675        case MOV_FOURCC('v','m','h','d'): {
     1676            dprintf("MOV: %*sVideo header!\n", level, "");
     1677            trak->type = MOV_TRAK_VIDEO;
     1678            // read video data
     1679            break;
     1680        }
     1681        case MOV_FOURCC('s','m','h','d'): {
     1682            dprintf("MOV: %*sSound header!\n", level, "");
     1683            trak->type = MOV_TRAK_AUDIO;
     1684            // read audio data
     1685            break;
     1686        }
     1687        case MOV_FOURCC('g','m','h','d'): {
     1688            dprintf("MOV: %*sGeneric header!\n", level, "");
     1689            trak->type = MOV_TRAK_GENERIC;
     1690            break;
     1691        }
     1692        case MOV_FOURCC('n','m','h','d'): {
     1693            dprintf("MOV: %*sGeneric header!\n", level, "");
     1694            trak->type = MOV_TRAK_GENERIC;
     1695            break;
     1696        }
     1697        case MOV_FOURCC('s','t','s','d'): {
     1698            int i = stream_read_dword(demuxer->stream); // temp!
     1699            int count = stream_read_dword(demuxer->stream);
     1700            dprintf("MOV: %*sDescription list! (cnt:%d)\n",
     1701                    level, "", count);
     1702            for (i = 0; i < count; i++) {
     1703                off_t pos = stream_tell(demuxer->stream);
     1704                off_t len = stream_read_dword(demuxer->stream);
     1705                unsigned int fourcc = stream_read_dword_le(demuxer->stream);
     1706                /* some files created with Broadcast 2000 (e.g. ilacetest.mov)
     1707                 contain raw I420 video but have a yv12 fourcc */
     1708                if (fourcc == mmioFOURCC('y','v','1','2'))
     1709                    fourcc = mmioFOURCC('I','4','2','0');
     1710                if (len < 8)
     1711                    break; // error
     1712                dprintf("MOV: %*s desc #%d: %.4s  (%"PRId64" bytes)\n", level, "",
     1713                        i, (char *)&fourcc, (int64_t)len - 16);
     1714                if (fourcc != trak->fourcc && i)
     1715                    dprintf("MOW: warning - different fourcc\n");
     1716                //      if(!i)
     1717                {
     1718                    trak->fourcc = fourcc;
     1719                    // read type specific (audio/video/time/text etc) header
     1720                    // NOTE: trak type is not yet known at this point :(((
     1721                    trak->stdata_len = len - 8;
     1722                    trak->stdata = malloc(trak->stdata_len);
     1723                    stream_read(demuxer->stream, trak->stdata, trak->stdata_len);
     1724                }
     1725                if (!stream_seek(demuxer->stream, pos + len))
     1726                    break;
     1727            }
     1728            break;
     1729        }
     1730        case MOV_FOURCC('s','t','t','s'): {
     1731            int temp = stream_read_dword(demuxer->stream);
     1732            int len = stream_read_dword(demuxer->stream);
     1733            int i;
     1734            unsigned int pts = 0;
     1735            dprintf("MOV: %*sSample duration table! (%d blocks)\n", level, "",
     1736                    len);
     1737            trak->durmap = calloc(len, sizeof(mov_durmap_t));
     1738            trak->durmap_size = len;
     1739            for (i = 0; i < len; i++) {
     1740                trak->durmap[i].num = stream_read_dword(demuxer->stream);
     1741                trak->durmap[i].dur = stream_read_dword(demuxer->stream);
     1742                pts += trak->durmap[i].num * trak->durmap[i].dur;
     1743            }
     1744            if (trak->length != pts)
     1745                dprintf( "Warning! pts=%d  length=%d\n",
     1746                        pts, trak->length);
     1747            break;
     1748        }
     1749        case MOV_FOURCC('s','t','s','c'): {
     1750            int temp = stream_read_dword(demuxer->stream);
     1751            int len = stream_read_dword(demuxer->stream);
     1752            int ver = (temp << 24);
     1753            int flags = (temp << 16) | (temp << 8) | temp;
     1754            int i;
     1755            dprintf("MOV: %*sSample->Chunk mapping table!  (%d blocks) (ver:%d,flags:%d)\n", level, "",
     1756                    len, ver, flags);
     1757            // read data:
     1758            trak->chunkmap_size = len;
     1759            trak->chunkmap = calloc(len, sizeof(mov_chunkmap_t));
     1760            for (i = 0; i < len; i++) {
     1761                trak->chunkmap[i].first = stream_read_dword(demuxer->stream) - 1;
     1762                trak->chunkmap[i].spc = stream_read_dword(demuxer->stream);
     1763                trak->chunkmap[i].sdid = stream_read_dword(demuxer->stream);
     1764            }
     1765            break;
     1766        }
     1767        case MOV_FOURCC('s','t','s','z'): {
     1768            int temp = stream_read_dword(demuxer->stream);
     1769            int ss=stream_read_dword(demuxer->stream);
     1770            int ver = (temp << 24);
     1771            int flags = (temp << 16) | (temp << 8) | temp;
     1772            int entries = stream_read_dword(demuxer->stream);
     1773            int i;
     1774            dprintf(
     1775                    "MOV: %*sSample size table! (entries=%d ss=%d) (ver:%d,flags:%d)\n", level, "",
     1776                    entries, ss, ver, flags);
     1777            trak->samplesize = ss;
     1778            if (!ss) {
     1779                // variable samplesize
     1780                trak->samples = realloc_struct(trak->samples, entries, sizeof(mov_sample_t));
     1781                trak->samples_size = entries;
     1782                for (i = 0; i < entries; i++)
     1783                    trak->samples[i].size = stream_read_dword(demuxer->stream);
     1784            }
     1785            break;
     1786        }
     1787        case MOV_FOURCC('s','t','c','o'): {
     1788            int temp = stream_read_dword(demuxer->stream);
     1789            int len = stream_read_dword(demuxer->stream);
     1790            int i;
     1791            dprintf(
     1792                    "MOV: %*sChunk offset table! (%d chunks)\n", level, "",
     1793                    len);
     1794            // extend array if needed:
     1795            if (len > trak->chunks_size) {
     1796                trak->chunks = realloc_struct(trak->chunks, len, sizeof(mov_chunk_t));
     1797                trak->chunks_size = len;
     1798            }
     1799            // read elements:
     1800            for(i = 0; i < len; i++)
     1801                trak->chunks[i].pos = stream_read_dword(demuxer->stream);
     1802            break;
     1803        }
     1804        case MOV_FOURCC('c','o','6','4'): {
     1805            int temp = stream_read_dword(demuxer->stream);
     1806            int len = stream_read_dword(demuxer->stream);
     1807            int i;
     1808            dprintf(
     1809                    "MOV: %*s64bit chunk offset table! (%d chunks)\n", level, "",
     1810                    len);
     1811            // extend array if needed:
     1812            if (len > trak->chunks_size) {
     1813                trak->chunks = realloc_struct(trak->chunks, len, sizeof(mov_chunk_t));
     1814                trak->chunks_size = len;
     1815            }
     1816            // read elements:
     1817            for (i = 0; i < len; i++) {
     1818#ifndef _LARGEFILE_SOURCE
     1819                if (stream_read_dword(demuxer->stream) != 0)
     1820                    dprintf( "Chunk %d has got 64bit address, but you've MPlayer compiled without LARGEFILE support!\n", i);
     1821                trak->chunks[i].pos = stream_read_dword(demuxer->stream);
     1822#else
     1823                trak->chunks[i].pos = stream_read_qword(demuxer->stream);
     1824#endif
     1825            }
     1826            break;
     1827        }
     1828        case MOV_FOURCC('s','t','s','s'): {
     1829            int temp = stream_read_dword(demuxer->stream);
     1830            int entries = stream_read_dword(demuxer->stream);
     1831            int ver = (temp << 24);
     1832            int flags = (temp << 16) | (temp<<8) | temp;
     1833            int i;
     1834            dprintf(
     1835                    "MOV: %*sSyncing samples (keyframes) table! (%d entries) (ver:%d,flags:%d)\n", level, "",
     1836                    entries, ver, flags);
     1837            trak->keyframes_size = entries;
     1838            trak->keyframes = calloc(entries, sizeof(unsigned int));
     1839            for (i = 0; i < entries; i++)
     1840                trak->keyframes[i] = stream_read_dword(demuxer->stream) - 1;
     1841            break;
     1842        }
     1843        case MOV_FOURCC('m','d','i','a'): {
     1844            dprintf( "MOV: %*sMedia stream!\n", level, "");
     1845            lschunks(demuxer, level + 1, pos + len, trak);
     1846            break;
     1847        }
     1848        case MOV_FOURCC('m','i','n','f'): {
     1849            dprintf( "MOV: %*sMedia info!\n", level, "");
     1850            lschunks(demuxer, level + 1 ,pos + len, trak);
     1851            break;
     1852        }
     1853        case MOV_FOURCC('s','t','b','l'): {
     1854            dprintf( "MOV: %*sSample info!\n", level, "");
     1855            lschunks(demuxer, level + 1, pos + len, trak);
     1856            break;
     1857        }
     1858        case MOV_FOURCC('e','d','t','s'): {
     1859            dprintf( "MOV: %*sEdit atom!\n", level, "");
     1860            lschunks(demuxer, level + 1, pos + len, trak);
     1861            break;
     1862        }
     1863        case MOV_FOURCC('e','l','s','t'): {
     1864            int temp = stream_read_dword(demuxer->stream);
     1865            int entries = stream_read_dword(demuxer->stream);
     1866            int ver = (temp << 24);
     1867            int flags = (temp << 16) | (temp << 8) | temp;
     1868            int i;
     1869            dprintf(
     1870                    "MOV: %*sEdit list table (%d entries) (ver:%d,flags:%d)\n", level, "",
     1871                    entries, ver, flags);
     1872#if 1
     1873            trak->editlist_size = entries;
     1874            trak->editlist = calloc(trak->editlist_size, sizeof(mov_editlist_t));
     1875            for (i = 0; i < entries; i++) {
     1876                int dur = stream_read_dword(demuxer->stream);
     1877                int mt = stream_read_dword(demuxer->stream);
     1878                int mr = stream_read_dword(demuxer->stream); // 16.16fp
     1879                trak->editlist[i].dur = dur;
     1880                trak->editlist[i].pos = mt;
     1881                trak->editlist[i].speed = mr;
     1882                dprintf(
     1883                        "MOV: %*s  entry#%d: duration: %d  start time: %d  speed: %3.1fx\n", level, "",
     1884                        i, dur, mt, (float)mr/65536.0f);
     1885            }
     1886#endif
     1887            break;
     1888        }
     1889        case MOV_FOURCC('c','o','d','e'): {
     1890            /* XXX: Implement atom 'code' for FLASH support */
     1891            break;
     1892        }
     1893        default:
     1894            id = be2me_32(id);
     1895            dprintf("MOV: unknown chunk: %.4s %d\n",(char *)&id,(int)len);
     1896            break;
     1897        }//switch(id)
     1898        return 0;
     1899    }
     1900
     1901    static demuxer_t* mov_read_header(demuxer_t* demuxer){
     1902        mov_priv_t* priv=demuxer->priv;
     1903        int t_no;
     1904        int best_a_id=-1, best_a_len=0;
     1905        int best_v_id=-1, best_v_len=0;
     1906
     1907        dprintf( "mov_read_header!\n");
     1908
     1909        // Parse header:
     1910        stream_reset(demuxer->stream);
     1911        if(!stream_seek(demuxer->stream,priv->moov_start))
     1912        {
     1913            dprintf("MOV: Cannot seek to the beginning of the Movie header (0x%"PRIx64")\n",
     1914                    (int64_t)priv->moov_start);
     1915            return 0;
     1916        }
     1917        lschunks(demuxer, 0, priv->moov_end, NULL);
     1918        // just in case we have hit eof while parsing...
     1919        demuxer->stream->eof = 0;
     1920        //    dprintf( "--------------\n");
     1921
     1922        // find the best (longest) streams:
     1923        for(t_no=0;t_no<priv->track_db;t_no++){
     1924            mov_track_t* trak=priv->tracks[t_no];
     1925            int len=(trak->samplesize) ? trak->chunks_size : trak->samples_size;
     1926            if(demuxer->a_streams[t_no]){ // need audio
     1927                if(len>best_a_len){     best_a_len=len; best_a_id=t_no; }
     1928            }
     1929            if(demuxer->v_streams[t_no]){ // need video
     1930                if(len>best_v_len){     best_v_len=len; best_v_id=t_no; }
     1931            }
     1932        }
     1933        dprintf( "MOV: longest streams: A: #%d (%d samples)  V: #%d (%d samples)\n",
     1934                best_a_id,best_a_len,best_v_id,best_v_len);
     1935        if(demuxer->audio->id==-1 && best_a_id>=0) demuxer->audio->id=best_a_id;
     1936        if(demuxer->video->id==-1 && best_v_id>=0) demuxer->video->id=best_v_id;
     1937
     1938        // setup sh pointers:
     1939        if(demuxer->audio->id>=0){
     1940            sh_audio_t* sh=demuxer->a_streams[demuxer->audio->id];
     1941            if(sh){
     1942                demuxer->audio->sh=sh; sh->ds=demuxer->audio;
     1943            } else {
     1944                dprintf( "MOV: selected audio stream (%d) does not exists\n",demuxer->audio->id);
     1945                demuxer->audio->id=-2;
     1946            }
     1947        }
     1948        if(demuxer->video->id>=0){
     1949            sh_video_t* sh=demuxer->v_streams[demuxer->video->id];
     1950            if(sh){
     1951                demuxer->video->sh=sh; sh->ds=demuxer->video;
     1952            } else {
     1953                dprintf( "MOV: selected video stream (%d) does not exists\n",demuxer->video->id);
     1954                demuxer->video->id=-2;
     1955            }
     1956        }
     1957
     1958        if(demuxer->sub->id>=0){
     1959            sh_sub_t* sh=demuxer->s_streams[demuxer->sub->id];
     1960            if(sh){
     1961                demuxer->sub->sh=sh;
     1962            } else {
     1963                dprintf("MOV: selected video stream (%d) does not exists\n",demuxer->video->id);
     1964                demuxer->sub->id=-2;
     1965            }
     1966        }
     1967        if(demuxer->video->id<0 && demuxer->audio->id<0) {
     1968            /* No AV streams found. Try to find an MPEG stream. */
     1969            for(t_no=0;t_no<priv->track_db;t_no++){
     1970                mov_track_t* trak=priv->tracks[t_no];
     1971                if(trak->media_handler == MOV_FOURCC('M','P','E','G')) {
     1972                    stream_t *s;
     1973                    demuxer_t *od;
     1974
     1975                    demuxer->video->id = t_no;
     1976                    s = new_ds_stream(demuxer->video);
     1977                    od = demux_open(s, DEMUXER_TYPE_MPEG_PS, -1, -1, -1, NULL);
     1978                    if(od) return new_demuxers_demuxer(od, od, od);
     1979                    demuxer->video->id = -2;        //new linked demuxer couldn't be allocated
    12911980                    break;
    12921981                }
    1293                 case MOV_TRAK_GENERIC:
    1294                     dprintf( "Generic track - not completely understood! (id: %d)\n",
    1295                             trak->id);
    1296                     /* XXX: Also this contains the FLASH data */
     1982            }
     1983        }
    12971984
    12981985#if 0
     1986        if( mp_msg_test(MSGL_DBG3) ){
     1987            for(t_no=0;t_no<priv->track_db;t_no++){
     1988                mov_track_t* trak=priv->tracks[t_no];
     1989                if(trak->type==MOV_TRAK_GENERIC){
     1990                    int i;
     1991                    int fd;
     1992                    char name[20];
     1993                    dprintf( "MOV: Track #%d: Extracting %d data chunks to files\n",t_no,trak->samples_size);
     1994                    for (i=0; i<trak->samples_size; i++)
    12991995                    {
    1300                         int pos = stream_tell(demuxer->stream);
    1301                         int i;
    1302                         int fd;
    1303                         char name[20];
    1304 
    1305                         for (i=0; i<trak->samples_size; i++)
     1996                        int len=trak->samples[i].size;
     1997                        char buf[len];
     1998                        stream_seek(demuxer->stream, trak->samples[i].pos);
     1999                        snprintf(name, 20, "t%02d-s%03d.%s", t_no,i,
     2000                                 (trak->media_handler==MOV_FOURCC('f','l','s','h')) ?
     2001                                 "swf":"dump");
     2002                        fd = open(name, O_CREAT|O_WRONLY);
     2003                        //                  { int j;
     2004                        //                      for(j=0;j<trak->stdata_len-3; j++)
     2005                        //                          printf("stdata[%d]=0x%X ize=0x%X\n",j,char2int(trak->stdata,j),MOV_FOURCC('z','l','i','b'));
     2006                        //                  }
     2007                        if( //trak->media_handler==MOV_FOURCC('s','p','r','t') &&
     2008                           trak->stdata_len>=16 &&
     2009                           char2int(trak->stdata,12)==MOV_FOURCC('z','l','i','b')
     2010                          ){
     2011                            int newlen=stream_read_dword(demuxer->stream);
     2012#ifdef HAVE_ZLIB
     2013                            // unzip:
     2014                            z_stream zstrm;
     2015                            int zret;
     2016                            char buf2[newlen];
     2017
     2018                            len-=4;
     2019                            stream_read(demuxer->stream, buf, len);
     2020
     2021                            zstrm.zalloc          = (alloc_func)0;
     2022                            zstrm.zfree           = (free_func)0;
     2023                            zstrm.opaque          = (voidpf)0;
     2024                            zstrm.next_in         = buf;
     2025                            zstrm.avail_in        = len;
     2026                            zstrm.next_out        = buf2;
     2027                            zstrm.avail_out       = newlen;
     2028
     2029                            zret = inflateInit(&zstrm);
     2030                            zret = inflate(&zstrm, Z_NO_FLUSH);
     2031                            if(newlen != zstrm.total_out)
     2032                                dprintf( "Warning! unzipped frame size differs hdr: %d  zlib: %ld\n",newlen,zstrm.total_out);
     2033
     2034                            write(fd, buf2, newlen);
     2035                        } else {
     2036#else
     2037                            len-=4;
     2038                            dprintf( "******* ZLIB COMPRESSED SAMPLE!!!!! (%d->%d bytes) *******\n",len,newlen);
     2039                        }
    13062040                        {
    1307                             char buf[trak->samples[i].size];
    1308                             stream_seek(demuxer->stream, trak->samples[i].pos);
    1309                             snprintf((char *)&name[0], 20, "samp%d", i);
    1310                             fd = open((char *)&name[0], O_CREAT|O_WRONLY);
    1311                             stream_read(demuxer->stream, &buf[0], trak->samples[i].size);
    1312                             write(fd, &buf[0], trak->samples[i].size);
    1313                             close(fd);
     2041#endif
     2042                            stream_read(demuxer->stream, buf, len);
     2043                            write(fd, buf, len);
    13142044                        }
    1315                         for (i=0; i<trak->chunks_size; i++)
    1316                         {
    1317                             char buf[trak->length];
    1318                             stream_seek(demuxer->stream, trak->chunks[i].pos);
    1319                             snprintf((char *)&name[0], 20, "chunk%d", i);
    1320                             fd = open((char *)&name[0], O_CREAT|O_WRONLY);
    1321                             stream_read(demuxer->stream, &buf[0], trak->length);
    1322                             write(fd, &buf[0], trak->length);
    1323                             close(fd);
    1324                         }
    1325                         if (trak->samplesize > 0)
    1326                         {
    1327                             char *buf;
    1328 
    1329                             buf = malloc(trak->samplesize);
    1330                             stream_seek(demuxer->stream, trak->chunks[0].pos);
    1331                             snprintf((char *)&name[0], 20, "trak%d", trak->id);
    1332                             fd = open((char *)&name[0], O_CREAT|O_WRONLY);
    1333                             stream_read(demuxer->stream, buf, trak->samplesize);
    1334                             write(fd, buf, trak->samplesize);
    1335                             close(fd);
    1336                         }
    1337                         stream_seek(demuxer->stream, pos);
     2045                        close(fd);
    13382046                    }
     2047                }
     2048            }
     2049        }
     2050        demuxer->stream->eof = 0;
    13392051#endif
    1340                     break;
    1341                 default:
    1342                     dprintf( "Unknown track type found (type: %d)\n", trak->type);
    1343                     break;
     2052        return demuxer;
     2053    }
     2054
     2055    /**
     2056     * \brief return the mov track that belongs to a demuxer stream
     2057     * \param ds the demuxer stream, may be NULL
     2058     * \return the mov track info structure belonging to the stream,
     2059     *          NULL if not found
     2060     */
     2061    static mov_track_t *stream_track(mov_priv_t *priv, demux_stream_t *ds) {
     2062        if (ds && (ds->id >= 0) && (ds->id < priv->track_db))
     2063            return priv->tracks[ds->id];
     2064        return NULL;
     2065    }
     2066
     2067    // return value:
     2068    //     0 = EOF or no stream found
     2069    //     1 = successfully read a packet
     2070    static int demux_mov_fill_buffer(demuxer_t *demuxer,demux_stream_t* ds){
     2071        mov_priv_t* priv=demuxer->priv;
     2072        mov_track_t* trak=NULL;
     2073        float pts;
     2074        int x;
     2075        off_t pos;
     2076
     2077        if (ds->eof) return 0;
     2078        trak = stream_track(priv, ds);
     2079        if (!trak) return 0;
     2080
     2081        if(trak->samplesize){
     2082            // read chunk:
     2083            if(trak->pos>=trak->chunks_size) return 0; // EOF
     2084            stream_seek(demuxer->stream,trak->chunks[trak->pos].pos);
     2085            pts=(float)(trak->chunks[trak->pos].sample*trak->duration)/(float)trak->timescale;
     2086            if(trak->samplesize!=1)
     2087            {
     2088                dprintf( "WARNING! Samplesize(%d) != 1\n",
     2089                        trak->samplesize);
     2090                if((trak->fourcc != MOV_FOURCC('t','w','o','s')) && (trak->fourcc != MOV_FOURCC('s','o','w','t')))
     2091                    x=trak->chunks[trak->pos].size*trak->samplesize;
     2092                else
     2093                    x=trak->chunks[trak->pos].size;
     2094            }
     2095            x=trak->chunks[trak->pos].size;
     2096            //    printf("X = %d\n", x);
     2097            /* the following stuff is audio related */
     2098            if (trak->type == MOV_TRAK_AUDIO){
     2099                if(trak->stdata_len>=44 && trak->stdata[9]>=1 && char2int(trak->stdata,28)>0){
     2100                    // stsd version 1 - we have audio compression ratio info:
     2101                    x/=char2int(trak->stdata,28); // samples/packet
     2102                    //  x*=char2int(trak->stdata,32); // bytes/packet
     2103                    x*=char2int(trak->stdata,36); // bytes/frame
     2104                } else {
     2105                    if(ds->ss_div && ds->ss_mul){
     2106                        // workaround for buggy files like 7up-high-traffic-areas.mov,
     2107                        // with missing stsd v1 header containing compression rate
     2108                        x/=ds->ss_div; x*=ds->ss_mul; // compression ratio fix  ! HACK !
     2109                    } else {
     2110                        x*=trak->nchannels;
     2111                        x*=trak->samplebytes;
     2112                    }
    13442113                }
    1345                 dprintf( "--------------\n");
    1346                 priv->track_db++;
    1347                 trak=NULL;
    1348                 break;
    1349             }
    1350 #ifndef HAVE_ZLIB
    1351             case MOV_FOURCC('c','m','o','v'): {
    1352                 dprintf("MOV: got compressed header but have no zlib\n");
    1353                 return;
    1354             }
    1355 #else
    1356             case MOV_FOURCC('m','o','o','v'):
    1357             case MOV_FOURCC('c','m','o','v'): {
    1358                 //          dprintf(MSGTR_MOVcomprhdr);
    1359                 lschunks(demuxer,level+1,pos+len,NULL);
    1360                 break;
    1361             }
    1362             case MOV_FOURCC('d','c','o','m'): {
    1363                 //          int temp=stream_read_dword(demuxer->stream);
    1364                 unsigned int algo=be2me_32(stream_read_dword(demuxer->stream));
    1365                 dprintf( "Compressed header uses %.4s algo!\n",(char *)&algo);
    1366                 break;
    1367             }
    1368             case MOV_FOURCC('c','m','v','d'): {
    1369                 //          int temp=stream_read_dword(demuxer->stream);
    1370                 unsigned int moov_sz=stream_read_dword(demuxer->stream);
    1371                 unsigned int cmov_sz=len-4;
    1372                 unsigned char* cmov_buf;
    1373                 unsigned char* moov_buf;
    1374                 int zret;
    1375                 z_stream zstrm;
    1376                 stream_t* backup;
    1377 
    1378                 if (moov_sz > 0xffffffff - 16) {
    1379                     dprintf("Invalid cmvd atom size %d\n", moov_sz);
    1380                     break;
     2114                dprintf( "Audio sample %d bytes pts %5.3f\n",trak->chunks[trak->pos].size*trak->samplesize,pts);
     2115            } /* MOV_TRAK_AUDIO */
     2116            pos=trak->chunks[trak->pos].pos;
     2117        } else {
     2118            int frame=trak->pos;
     2119            // editlist support:
     2120            if(trak->type == MOV_TRAK_VIDEO && trak->editlist_size>=1){
     2121                // find the right editlist entry:
     2122                if(frame<trak->editlist[trak->editlist_pos].start_frame)
     2123                    trak->editlist_pos=0;
     2124                while(trak->editlist_pos<trak->editlist_size-1 &&
     2125                      frame>=trak->editlist[trak->editlist_pos+1].start_frame)
     2126                    ++trak->editlist_pos;
     2127                if(frame>=trak->editlist[trak->editlist_pos].start_frame+
     2128                   trak->editlist[trak->editlist_pos].frames) return 0; // EOF
     2129                // calc real frame index:
     2130                frame-=trak->editlist[trak->editlist_pos].start_frame;
     2131                frame+=trak->editlist[trak->editlist_pos].start_sample;
     2132                // calc pts:
     2133                pts=(float)(trak->samples[frame].pts+
     2134                            trak->editlist[trak->editlist_pos].pts_offset)/(float)trak->timescale;
     2135            } else {
     2136                if(frame>=trak->samples_size) return 0; // EOF
     2137                pts=(float)trak->samples[frame].pts/(float)trak->timescale;
     2138            }
     2139            // read sample:
     2140            stream_seek(demuxer->stream,trak->samples[frame].pos);
     2141            x=trak->samples[frame].size;
     2142            pos=trak->samples[frame].pos;
     2143        }
     2144        if(trak->pos==0 && trak->stream_header_len>0){
     2145            // we have to append the stream header...
     2146            demux_packet_t* dp=new_demux_packet(x+trak->stream_header_len);
     2147            memcpy(dp->buffer,trak->stream_header,trak->stream_header_len);
     2148            stream_read(demuxer->stream,dp->buffer+trak->stream_header_len,x);
     2149            free(trak->stream_header);
     2150            trak->stream_header = NULL;
     2151            trak->stream_header_len = 0;
     2152            dp->pts=pts;
     2153            dp->flags=0;
     2154            dp->pos=pos; // FIXME?
     2155            ds_add_packet(ds,dp);
     2156        } else
     2157            ds_read_packet(ds,demuxer->stream,x,pts,pos,0);
     2158
     2159        ++trak->pos;
     2160        if (demuxer->sub->id >= 0) {
     2161            int samplenr = 0;
     2162            trak = priv->tracks[demuxer->sub->id];
     2163            while (samplenr < trak->samples_size) {
     2164                double subpts = (double)trak->samples[samplenr].pts / (double)trak->timescale;
     2165                if (subpts >= pts) break;
     2166                samplenr++;
     2167            }
     2168            samplenr--;
     2169            if (samplenr < 0)
     2170                vo_sub = NULL;
     2171            else if (samplenr != priv->current_sub) {
     2172                sh_sub_t *sh = demuxer->sub->sh;
     2173                off_t pos = trak->samples[samplenr].pos;
     2174                int len = trak->samples[samplenr].size;
     2175                double subpts = (double)trak->samples[samplenr].pts / (double)trak->timescale;
     2176                stream_seek(demuxer->stream, pos);
     2177                if (sh->type == 'v')
     2178                    ds_read_packet(demuxer->sub, demuxer->stream, len, subpts, pos, 0);
     2179                else {
     2180                    int i;
     2181                    char *line = priv->subtext;
     2182                    stream_skip(demuxer->stream, 2); // size
     2183                    len -= 2;
     2184                    if (len < 0) len = 0;
     2185                    if (len > MOV_MAX_SUBLEN) len = MOV_MAX_SUBLEN;
     2186                    stream_read(demuxer->stream, priv->subtext, len);
     2187                    priv->subtext[len] = 0;
     2188                    priv->subs.lines = 1;
     2189                    priv->subs.text[0] = &priv->subtext;
     2190                    while ((line = strchr(line, '\n'))) {
     2191                        *line++ = 0;
     2192                        priv->subs.text[priv->subs.lines] = line;
     2193                        priv->subs.lines++;
     2194                    }
     2195                    vo_sub = &priv->subs;
    13812196                }
    1382                 cmov_buf=malloc(cmov_sz);
    1383                 moov_buf=malloc(moov_sz+16);
    1384                 dprintf( "Compressed header size: %d / %d\n",cmov_sz,moov_sz);
    1385 
    1386                 stream_read(demuxer->stream,cmov_buf,cmov_sz);
    1387 
    1388                 zstrm.zalloc          = (alloc_func)0;
    1389                 zstrm.zfree           = (free_func)0;
    1390                 zstrm.opaque          = (voidpf)0;
    1391                 zstrm.next_in         = cmov_buf;
    1392                 zstrm.avail_in        = cmov_sz;
    1393                 zstrm.next_out        = moov_buf;
    1394                 zstrm.avail_out       = moov_sz;
    1395 
    1396                 zret = inflateInit(&zstrm);
    1397                 if (zret != Z_OK)
    1398                 { dprintf( "QT cmov: inflateInit err %d\n",zret);
    1399                     return;
     2197                priv->current_sub = samplenr;
     2198            }
     2199            vo_osd_changed (OSDTYPE_SUBTITLE);
     2200        }
     2201
     2202        return 1;
     2203
     2204    }
     2205
     2206    static float mov_seek_track(mov_track_t* trak,float pts,int flags){
     2207
     2208        //    printf("MOV track seek called  %5.3f  \n",pts);
     2209        if(flags&2) pts*=trak->length; else pts*=(float)trak->timescale;
     2210
     2211        if(trak->samplesize){
     2212            int sample=pts/trak->duration;
     2213            //    printf("MOV track seek - chunk: %d  (pts: %5.3f  dur=%d)  \n",sample,pts,trak->duration);
     2214            if(!(flags&1)) sample+=trak->chunks[trak->pos].sample; // relative
     2215            trak->pos=0;
     2216            while(trak->pos<trak->chunks_size && trak->chunks[trak->pos].sample<sample) ++trak->pos;
     2217            if (trak->pos == trak->chunks_size) return -1;
     2218            pts=(float)(trak->chunks[trak->pos].sample*trak->duration)/(float)trak->timescale;
     2219        } else {
     2220            unsigned int ipts;
     2221            if(!(flags&1)) pts+=trak->samples[trak->pos].pts;
     2222            if(pts<0) pts=0;
     2223            ipts=pts;
     2224            //printf("MOV track seek - sample: %d  \n",ipts);
     2225            for(trak->pos=0;trak->pos<trak->samples_size;++trak->pos){
     2226                if(trak->samples[trak->pos].pts>=ipts) break; // found it!
     2227            }
     2228            if (trak->pos == trak->samples_size) return -1;
     2229            if(trak->keyframes_size){
     2230                // find nearest keyframe
     2231                int i;
     2232                for(i=0;i<trak->keyframes_size;i++){
     2233                    if(trak->keyframes[i]>=trak->pos) break;
    14002234                }
    1401                 zret = inflate(&zstrm, Z_NO_FLUSH);
    1402                 if ((zret != Z_OK) && (zret != Z_STREAM_END))
    1403                 { dprintf( "QT cmov inflate: ERR %d\n",zret);
    1404                     return;
    1405                 }
    1406 #if 0
    1407                 else {
    1408                     FILE *DecOut;
    1409                     DecOut = fopen("Out.bin", "w");
    1410                     fwrite(moov_buf, 1, moov_sz, DecOut);
    1411                     fclose(DecOut);
    1412                 }
    1413 #endif
    1414                 if(moov_sz != zstrm.total_out)
    1415                     dprintf( "Warning! moov size differs cmov: %d  zlib: %ld\n",moov_sz,zstrm.total_out);
    1416                 zret = inflateEnd(&zstrm);
    1417 
    1418                 backup=demuxer->stream;
    1419                 demuxer->stream=new_memory_stream(moov_buf,moov_sz);
    1420                 stream_skip(demuxer->stream,8);
    1421                 lschunks(demuxer,level+1,moov_sz,NULL); // parse uncompr. 'moov'
    1422                 //free_stream(demuxer->stream);
    1423                 demuxer->stream=backup;
    1424                 free(cmov_buf);
    1425                 free(moov_buf);
    1426                 break;
    1427             }
    1428 #endif
    1429             case MOV_FOURCC('u','d','t','a'):
    1430                 {
    1431                     unsigned int udta_id;
    1432                     off_t udta_len;
    1433                     off_t udta_size = len;
    1434 
    1435                     dprintf( "mov: user data record found\n");
    1436                     dprintf( "Quicktime Clip Info:\n");
    1437 
    1438                     while((len > 8) && (udta_size > 8))
    1439                     {
    1440                         udta_len = stream_read_dword(demuxer->stream);
    1441                         udta_id = stream_read_dword(demuxer->stream);
    1442                         udta_size -= 8;
    1443                         dprintf( "udta_id: %.4s (len: %"PRId64")\n", (char *)&udta_id, (int64_t)udta_len);
    1444                         switch (udta_id)
    1445                         {
    1446                         case MOV_FOURCC(0xa9,'c','p','y'):
    1447                         case MOV_FOURCC(0xa9,'d','a','y'):
    1448                         case MOV_FOURCC(0xa9,'d','i','r'):
    1449                             /* 0xa9,'e','d','1' - '9' : edit timestamps */
    1450                         case MOV_FOURCC(0xa9,'f','m','t'):
    1451                         case MOV_FOURCC(0xa9,'i','n','f'):
    1452                         case MOV_FOURCC(0xa9,'p','r','d'):
    1453                         case MOV_FOURCC(0xa9,'p','r','f'):
    1454                         case MOV_FOURCC(0xa9,'r','e','q'):
    1455                         case MOV_FOURCC(0xa9,'s','r','c'):
    1456                         case MOV_FOURCC('n','a','m','e'):
    1457                         case MOV_FOURCC(0xa9,'n','a','m'):
    1458                         case MOV_FOURCC(0xa9,'A','R','T'):
    1459                         case MOV_FOURCC(0xa9,'c','m','t'):
    1460                         case MOV_FOURCC(0xa9,'a','u','t'):
    1461                         case MOV_FOURCC(0xa9,'s','w','r'):
    1462                             {
    1463                                 off_t text_len = stream_read_word(demuxer->stream);
    1464                                 char text[text_len+2+1];
    1465                                 stream_read(demuxer->stream, (char *)&text, text_len+2);
    1466                                 text[text_len+2] = 0x0;
    1467                                 switch(udta_id)
    1468                                 {
    1469                                 case MOV_FOURCC(0xa9,'a','u','t'):
    1470                                     demux_info_add(demuxer, "author", &text[2]);
    1471                                     dprintf( " Author: %s\n", &text[2]);
    1472                                     break;
    1473                                 case MOV_FOURCC(0xa9,'c','p','y'):
    1474                                     demux_info_add(demuxer, "copyright", &text[2]);
    1475                                     dprintf( " Copyright: %s\n", &text[2]);
    1476                                     break;
    1477                                 case MOV_FOURCC(0xa9,'i','n','f'):
    1478                                     dprintf( " Info: %s\n", &text[2]);
    1479                                     break;
    1480                                 case MOV_FOURCC('n','a','m','e'):
    1481                                 case MOV_FOURCC(0xa9,'n','a','m'):
    1482                                     demux_info_add(demuxer, "name", &text[2]);
    1483                                     dprintf( " Name: %s\n", &text[2]);
    1484                                     break;
    1485                                 case MOV_FOURCC(0xa9,'A','R','T'):
    1486                                     dprintf( " Artist: %s\n", &text[2]);
    1487                                     break;
    1488                                 case MOV_FOURCC(0xa9,'d','i','r'):
    1489                                     dprintf( " Director: %s\n", &text[2]);
    1490                                     break;
    1491                                 case MOV_FOURCC(0xa9,'c','m','t'):
    1492                                     demux_info_add(demuxer, "comments", &text[2]);
    1493                                     dprintf( " Comment: %s\n", &text[2]);
    1494                                     break;
    1495                                 case MOV_FOURCC(0xa9,'r','e','q'):
    1496                                     dprintf( " Requirements: %s\n", &text[2]);
    1497                                     break;
    1498                                 case MOV_FOURCC(0xa9,'s','w','r'):
    1499                                     demux_info_add(demuxer, "encoder", &text[2]);
    1500                                     dprintf( " Software: %s\n", &text[2]);
    1501                                     break;
    1502                                 case MOV_FOURCC(0xa9,'d','a','y'):
    1503                                     dprintf( " Creation timestamp: %s\n", &text[2]);
    1504                                     break;
    1505                                 case MOV_FOURCC(0xa9,'f','m','t'):
    1506                                     dprintf( " Format: %s\n", &text[2]);
    1507                                     break;
    1508                                 case MOV_FOURCC(0xa9,'p','r','d'):
    1509                                     dprintf( " Producer: %s\n", &text[2]);
    1510                                     break;
    1511                                 case MOV_FOURCC(0xa9,'p','r','f'):
    1512                                     dprintf( " Performer(s): %s\n", &text[2]);
    1513                                     break;
    1514                                 case MOV_FOURCC(0xa9,'s','r','c'):
    1515                                     dprintf( " Source providers: %s\n", &text[2]);
    1516                                     break;
    1517                                 }
    1518                                 udta_size -= 4+text_len;
    1519                                 break;
    1520                             }
    1521                             /* some other shits:    WLOC - window location,
    1522                              LOOP - looping style,
    1523                              SelO - play only selected frames
    1524                              AllF - play all frames
    1525                              */
    1526                         case MOV_FOURCC('W','L','O','C'):
    1527                         case MOV_FOURCC('L','O','O','P'):
    1528                         case MOV_FOURCC('S','e','l','O'):
    1529                         case MOV_FOURCC('A','l','l','F'):
    1530                         default:
    1531                             {
    1532                                 if( udta_len>udta_size)
    1533                                     udta_len=udta_size;
    1534                                 {
    1535                                     char dump[udta_len-4];
    1536                                     stream_read(demuxer->stream, (char *)&dump, udta_len-4-4);
    1537                                     udta_size -= udta_len;
    1538                                 }
    1539                             }
    1540                         }
    1541                     }
    1542                     break;
    1543                 } /* eof udta */
    1544             default:
    1545                 id = be2me_32(id);
    1546                 dprintf("MOV: unknown chunk: %.4s %d\n",(char *)&id,(int)len);
    1547             } /* endof switch */
    1548         } /* endof else */
    1549 
    1550         pos+=len+8;
    1551         if(pos>=endpos) break;
    1552         if(!stream_seek(demuxer->stream,pos)) break;
     2235                if (i == trak->keyframes_size) return -1;
     2236                if(i>0 && (trak->keyframes[i]-trak->pos) > (trak->pos-trak->keyframes[i-1]))
     2237                    --i;
     2238                trak->pos=trak->keyframes[i];
     2239                //      printf("nearest keyframe: %d  \n",trak->pos);
     2240            }
     2241            pts=(float)trak->samples[trak->pos].pts/(float)trak->timescale;
     2242        }
     2243
     2244        //    printf("MOV track seek done:  %5.3f  \n",pts);
     2245
     2246        return pts;
    15532247    }
    1554 }
    1555 
    1556 static int lschunks_intrak(demuxer_t* demuxer, int level, unsigned int id,
    1557                            off_t pos, off_t len, mov_track_t* trak)
    1558 {
    1559   switch(id) {
    1560     case MOV_FOURCC('m','d','a','t'): {
    1561       dprintf("Hmm, strange MOV, parsing mdat in lschunks?\n");
    1562       return -1;
     2248
     2249    static void demux_seek_mov(demuxer_t *demuxer,float pts,int flags){
     2250        mov_priv_t* priv=demuxer->priv;
     2251        demux_stream_t* ds;
     2252        mov_track_t* trak;
     2253
     2254        //    printf("MOV seek called  %5.3f  flag=%d  \n",pts,flags);
     2255
     2256        ds=demuxer->video;
     2257        trak = stream_track(priv, ds);
     2258        if (trak) {
     2259            //if(flags&2) pts*=(float)trak->length/(float)trak->timescale;
     2260            //if(!(flags&1)) pts+=ds->pts;
     2261            ds->pts=mov_seek_track(trak,pts,flags);
     2262            if (ds->pts < 0) ds->eof = 1;
     2263            else pts = ds->pts;
     2264            flags=1; // absolute seconds
     2265        }
     2266
     2267        ds=demuxer->audio;
     2268        trak = stream_track(priv, ds);
     2269        if (trak) {
     2270            //if(flags&2) pts*=(float)trak->length/(float)trak->timescale;
     2271            //if(!(flags&1)) pts+=ds->pts;
     2272            ds->pts=mov_seek_track(trak,pts,flags);
     2273            if (ds->pts < 0) ds->eof = 1;
     2274            if (demuxer->video->id < 0)
     2275                ((sh_audio_t*)ds->sh)->delay = ds->pts;
     2276        }
     2277
    15632278    }
    1564     case MOV_FOURCC('f','r','e','e'):
    1565     case MOV_FOURCC('u','d','t','a'):
    1566       /* here not supported :p */
    1567       break;
    1568     case MOV_FOURCC('t','k','h','d'): {
    1569       dprintf("MOV: %*sTrack header!\n", level, "");
    1570       // read codec data
    1571       trak->tkdata_len = len;
    1572       trak->tkdata = malloc(trak->tkdata_len);
    1573       stream_read(demuxer->stream, trak->tkdata, trak->tkdata_len);
    1574 /*
    1575 0  1 Version
    1576 1  3 Flags
    1577 4  4 Creation time
    1578 8  4 Modification time
    1579 12 4 Track ID
    1580 16 4 Reserved
    1581 20 4 Duration
    1582 24 8 Reserved
    1583 32 2 Layer
    1584 34 2 Alternate group
    1585 36 2 Volume
    1586 38 2 Reserved
    1587 40 36 Matrix structure
    1588 76 4 Track width
    1589 80 4 Track height
    1590 */
    1591       dprintf(
    1592              "tkhd len=%d ver=%d flags=0x%X id=%d dur=%d lay=%d vol=%d\n",
    1593               trak->tkdata_len, trak->tkdata[0], trak->tkdata[1],
    1594               char2int(trak->tkdata, 12), // id
    1595               char2int(trak->tkdata, 20), // duration
    1596               char2short(trak->tkdata, 32), // layer
    1597               char2short(trak->tkdata, 36)); // volume
    1598       break;
     2279
     2280    static int demux_mov_control(demuxer_t *demuxer, int cmd, void *arg){
     2281        mov_track_t* track;
     2282
     2283        // try the video track
     2284        track = stream_track(demuxer->priv, demuxer->video);
     2285        if (!track || !track->length)
     2286            // otherwise try to get the info from the audio track
     2287            track = stream_track(demuxer->priv, demuxer->audio);
     2288
     2289        if (!track || !track->length)
     2290            return DEMUXER_CTRL_DONTKNOW;
     2291
     2292        switch(cmd) {
     2293        case DEMUXER_CTRL_GET_TIME_LENGTH:
     2294            if (!track->timescale)
     2295                return DEMUXER_CTRL_DONTKNOW;
     2296            *((double *)arg) = (double)track->length / track->timescale;
     2297            return DEMUXER_CTRL_OK;
     2298
     2299        case DEMUXER_CTRL_GET_PERCENT_POS:
     2300            {
     2301                off_t pos = track->pos;
     2302                if (track->durmap_size >= 1)
     2303                    pos *= track->durmap[0].dur;
     2304                *((int *)arg) = (int)(100 * pos / track->length);
     2305                return DEMUXER_CTRL_OK;
     2306            }
     2307        }
     2308        return DEMUXER_CTRL_NOTIMPL;
    15992309    }
    1600     case MOV_FOURCC('m','d','h','d'): {
    1601         dprintf( "MOV: %*sMedia header!\n", level, "");
    1602         int version = stream_read_char(demuxer->stream);
    1603         stream_skip(demuxer->stream, (version == 1) ? 19 : 11);
    1604         // read timescale
    1605         trak->timescale = stream_read_dword(demuxer->stream);
    1606         // read length
    1607         if (version == 1)
    1608             trak->length = stream_read_qword(demuxer->stream);
    1609         else
    1610             trak->length = stream_read_dword(demuxer->stream);
    1611       break;
    1612     }
    1613     case MOV_FOURCC('h','d','l','r'): {
    1614       unsigned int tmp = stream_read_dword(demuxer->stream);
    1615       unsigned int type = stream_read_dword_le(demuxer->stream);
    1616       unsigned int subtype = stream_read_dword_le(demuxer->stream);
    1617       unsigned int manufact = stream_read_dword_le(demuxer->stream);
    1618       unsigned int comp_flags = stream_read_dword(demuxer->stream);
    1619       unsigned int comp_mask = stream_read_dword(demuxer->stream);
    1620       int len = stream_read_char(demuxer->stream);
    1621       char* str = malloc(len + 1);
    1622       stream_read(demuxer->stream, str, len);
    1623       str[len] = 0;
    1624       dprintf(
    1625              "MOV: %*sHandler header: %.4s/%.4s (%.4s) %s\n", level, "",
    1626              (char *)&type, (char *)&subtype, (char *)&manufact, str);
    1627       free(str);
    1628       switch(bswap_32(type)) {
    1629         case MOV_FOURCC('m','h','l','r'):
    1630           trak->media_handler = bswap_32(subtype);
    1631           break;
    1632         case MOV_FOURCC('d','h','l','r'):
    1633           trak->data_handler = bswap_32(subtype);
    1634           break;
    1635         default:
    1636           dprintf(
    1637                  "MOV: unknown handler class: 0x%X (%.4s)\n",
    1638                  bswap_32(type), (char *)&type);
    1639       }
    1640       break;
    1641     }
    1642     case MOV_FOURCC('v','m','h','d'): {
    1643       dprintf( "MOV: %*sVideo header!\n", level, "");
    1644       trak->type = MOV_TRAK_VIDEO;
    1645       // read video data
    1646       break;
    1647     }
    1648     case MOV_FOURCC('s','m','h','d'): {
    1649       dprintf( "MOV: %*sSound header!\n", level, "");
    1650       trak->type = MOV_TRAK_AUDIO;
    1651       // read audio data
    1652       break;
    1653     }
    1654     case MOV_FOURCC('g','m','h','d'): {
    1655       dprintf( "MOV: %*sGeneric header!\n", level, "");
    1656       trak->type = MOV_TRAK_GENERIC;
    1657       break;
    1658     }
    1659     case MOV_FOURCC('n','m','h','d'): {
    1660       dprintf( "MOV: %*sGeneric header!\n", level, "");
    1661       trak->type = MOV_TRAK_GENERIC;
    1662       break;
    1663     }
    1664     case MOV_FOURCC('s','t','s','d'): {
    1665       int i = stream_read_dword(demuxer->stream); // temp!
    1666       int count = stream_read_dword(demuxer->stream);
    1667       dprintf( "MOV: %*sDescription list! (cnt:%d)\n",
    1668              level, "", count);
    1669       for (i = 0; i < count; i++) {
    1670         off_t pos = stream_tell(demuxer->stream);
    1671         off_t len = stream_read_dword(demuxer->stream);
    1672         unsigned int fourcc = stream_read_dword_le(demuxer->stream);
    1673         /* some files created with Broadcast 2000 (e.g. ilacetest.mov)
    1674            contain raw I420 video but have a yv12 fourcc */
    1675         if (fourcc == mmioFOURCC('y','v','1','2'))
    1676           fourcc = mmioFOURCC('I','4','2','0');
    1677         if (len < 8)
    1678           break; // error
    1679         dprintf(
    1680                "MOV: %*s desc #%d: %.4s  (%"PRId64" bytes)\n", level, "",
    1681                i, (char *)&fourcc, (int64_t)len - 16);
    1682         if (fourcc != trak->fourcc && i)
    1683             dprintf("MOW: warning - different fourcc\n");
    1684 //      if(!i)
    1685         {
    1686           trak->fourcc = fourcc;
    1687           // read type specific (audio/video/time/text etc) header
    1688           // NOTE: trak type is not yet known at this point :(((
    1689           trak->stdata_len = len - 8;
    1690           trak->stdata = malloc(trak->stdata_len);
    1691           stream_read(demuxer->stream, trak->stdata, trak->stdata_len);
    1692         }
    1693         if (!stream_seek(demuxer->stream, pos + len))
    1694           break;
    1695       }
    1696       break;
    1697     }
    1698     case MOV_FOURCC('s','t','t','s'): {
    1699       int temp = stream_read_dword(demuxer->stream);
    1700       int len = stream_read_dword(demuxer->stream);
    1701       int i;
    1702       unsigned int pts = 0;
    1703       dprintf(
    1704              "MOV: %*sSample duration table! (%d blocks)\n", level, "",
    1705               len);
    1706       trak->durmap = calloc(len, sizeof(mov_durmap_t));
    1707       trak->durmap_size = len;
    1708       for (i = 0; i < len; i++) {
    1709         trak->durmap[i].num = stream_read_dword(demuxer->stream);
    1710         trak->durmap[i].dur = stream_read_dword(demuxer->stream);
    1711         pts += trak->durmap[i].num * trak->durmap[i].dur;
    1712       }
    1713       if (trak->length != pts)
    1714         dprintf( "Warning! pts=%d  length=%d\n",
    1715                pts, trak->length);
    1716       break;
    1717     }
    1718     case MOV_FOURCC('s','t','s','c'): {
    1719       int temp = stream_read_dword(demuxer->stream);
    1720       int len = stream_read_dword(demuxer->stream);
    1721       int ver = (temp << 24);
    1722       int flags = (temp << 16) | (temp << 8) | temp;
    1723       int i;
    1724       dprintf(
    1725              "MOV: %*sSample->Chunk mapping table!  (%d blocks) (ver:%d,flags:%d)\n", level, "",
    1726              len, ver, flags);
    1727       // read data:
    1728       trak->chunkmap_size = len;
    1729       trak->chunkmap = calloc(len, sizeof(mov_chunkmap_t));
    1730       for (i = 0; i < len; i++) {
    1731         trak->chunkmap[i].first = stream_read_dword(demuxer->stream) - 1;
    1732         trak->chunkmap[i].spc = stream_read_dword(demuxer->stream);
    1733         trak->chunkmap[i].sdid = stream_read_dword(demuxer->stream);
    1734       }
    1735       break;
    1736     }
    1737     case MOV_FOURCC('s','t','s','z'): {
    1738       int temp = stream_read_dword(demuxer->stream);
    1739       int ss=stream_read_dword(demuxer->stream);
    1740       int ver = (temp << 24);
    1741       int flags = (temp << 16) | (temp << 8) | temp;
    1742       int entries = stream_read_dword(demuxer->stream);
    1743       int i;
    1744       dprintf(
    1745              "MOV: %*sSample size table! (entries=%d ss=%d) (ver:%d,flags:%d)\n", level, "",
    1746              entries, ss, ver, flags);
    1747       trak->samplesize = ss;
    1748       if (!ss) {
    1749           // variable samplesize
    1750           trak->samples = realloc_struct(trak->samples, entries, sizeof(mov_sample_t));
    1751           trak->samples_size = entries;
    1752           for (i = 0; i < entries; i++)
    1753               trak->samples[i].size = stream_read_dword(demuxer->stream);
    1754       }
    1755       break;
    1756     }
    1757     case MOV_FOURCC('s','t','c','o'): {
    1758       int temp = stream_read_dword(demuxer->stream);
    1759       int len = stream_read_dword(demuxer->stream);
    1760       int i;
    1761       dprintf(
    1762              "MOV: %*sChunk offset table! (%d chunks)\n", level, "",
    1763              len);
    1764       // extend array if needed:
    1765       if (len > trak->chunks_size) {
    1766           trak->chunks = realloc_struct(trak->chunks, len, sizeof(mov_chunk_t));
    1767           trak->chunks_size = len;
    1768       }
    1769       // read elements:
    1770       for(i = 0; i < len; i++)
    1771         trak->chunks[i].pos = stream_read_dword(demuxer->stream);
    1772       break;
    1773     }
    1774     case MOV_FOURCC('c','o','6','4'): {
    1775       int temp = stream_read_dword(demuxer->stream);
    1776       int len = stream_read_dword(demuxer->stream);
    1777       int i;
    1778       dprintf(
    1779              "MOV: %*s64bit chunk offset table! (%d chunks)\n", level, "",
    1780              len);
    1781       // extend array if needed:
    1782       if (len > trak->chunks_size) {
    1783           trak->chunks = realloc_struct(trak->chunks, len, sizeof(mov_chunk_t));
    1784           trak->chunks_size = len;
    1785       }
    1786       // read elements:
    1787       for (i = 0; i < len; i++) {
    1788 #ifndef _LARGEFILE_SOURCE
    1789         if (stream_read_dword(demuxer->stream) != 0)
    1790           dprintf( "Chunk %d has got 64bit address, but you've MPlayer compiled without LARGEFILE support!\n", i);
    1791         trak->chunks[i].pos = stream_read_dword(demuxer->stream);
    1792 #else
    1793         trak->chunks[i].pos = stream_read_qword(demuxer->stream);
    1794 #endif
    1795       }
    1796       break;
    1797     }
    1798     case MOV_FOURCC('s','t','s','s'): {
    1799       int temp = stream_read_dword(demuxer->stream);
    1800       int entries = stream_read_dword(demuxer->stream);
    1801       int ver = (temp << 24);
    1802       int flags = (temp << 16) | (temp<<8) | temp;
    1803       int i;
    1804       dprintf(
    1805              "MOV: %*sSyncing samples (keyframes) table! (%d entries) (ver:%d,flags:%d)\n", level, "",
    1806              entries, ver, flags);
    1807       trak->keyframes_size = entries;
    1808       trak->keyframes = calloc(entries, sizeof(unsigned int));
    1809       for (i = 0; i < entries; i++)
    1810           trak->keyframes[i] = stream_read_dword(demuxer->stream) - 1;
    1811       break;
    1812     }
    1813     case MOV_FOURCC('m','d','i','a'): {
    1814       dprintf( "MOV: %*sMedia stream!\n", level, "");
    1815       lschunks(demuxer, level + 1, pos + len, trak);
    1816       break;
    1817     }
    1818     case MOV_FOURCC('m','i','n','f'): {
    1819       dprintf( "MOV: %*sMedia info!\n", level, "");
    1820       lschunks(demuxer, level + 1 ,pos + len, trak);
    1821       break;
    1822     }
    1823     case MOV_FOURCC('s','t','b','l'): {
    1824       dprintf( "MOV: %*sSample info!\n", level, "");
    1825       lschunks(demuxer, level + 1, pos + len, trak);
    1826       break;
    1827     }
    1828     case MOV_FOURCC('e','d','t','s'): {
    1829       dprintf( "MOV: %*sEdit atom!\n", level, "");
    1830       lschunks(demuxer, level + 1, pos + len, trak);
    1831       break;
    1832     }
    1833     case MOV_FOURCC('e','l','s','t'): {
    1834       int temp = stream_read_dword(demuxer->stream);
    1835       int entries = stream_read_dword(demuxer->stream);
    1836       int ver = (temp << 24);
    1837       int flags = (temp << 16) | (temp << 8) | temp;
    1838       int i;
    1839       dprintf(
    1840              "MOV: %*sEdit list table (%d entries) (ver:%d,flags:%d)\n", level, "",
    1841              entries, ver, flags);
    1842 #if 1
    1843       trak->editlist_size = entries;
    1844       trak->editlist = calloc(trak->editlist_size, sizeof(mov_editlist_t));
    1845       for (i = 0; i < entries; i++) {
    1846         int dur = stream_read_dword(demuxer->stream);
    1847         int mt = stream_read_dword(demuxer->stream);
    1848         int mr = stream_read_dword(demuxer->stream); // 16.16fp
    1849         trak->editlist[i].dur = dur;
    1850         trak->editlist[i].pos = mt;
    1851         trak->editlist[i].speed = mr;
    1852         dprintf(
    1853                "MOV: %*s  entry#%d: duration: %d  start time: %d  speed: %3.1fx\n", level, "",
    1854                 i, dur, mt, (float)mr/65536.0f);
    1855       }
    1856 #endif
    1857       break;
    1858     }
    1859     case MOV_FOURCC('c','o','d','e'): {
    1860       /* XXX: Implement atom 'code' for FLASH support */
    1861       break;
    1862     }
    1863     default:
    1864       id = be2me_32(id);
    1865       dprintf("MOV: unknown chunk: %.4s %d\n",(char *)&id,(int)len);
    1866       break;
    1867   }//switch(id)
    1868   return 0;
    1869 }
    1870 
    1871 static demuxer_t* mov_read_header(demuxer_t* demuxer){
    1872     mov_priv_t* priv=demuxer->priv;
    1873     int t_no;
    1874     int best_a_id=-1, best_a_len=0;
    1875     int best_v_id=-1, best_v_len=0;
    1876 
    1877     dprintf( "mov_read_header!\n");
    1878 
    1879     // Parse header:
    1880     stream_reset(demuxer->stream);
    1881     if(!stream_seek(demuxer->stream,priv->moov_start))
    1882     {
    1883         dprintf("MOV: Cannot seek to the beginning of the Movie header (0x%"PRIx64")\n",
    1884             (int64_t)priv->moov_start);
    1885         return 0;
    1886     }
    1887     lschunks(demuxer, 0, priv->moov_end, NULL);
    1888     // just in case we have hit eof while parsing...
    1889     demuxer->stream->eof = 0;
    1890 //    dprintf( "--------------\n");
    1891 
    1892     // find the best (longest) streams:
    1893     for(t_no=0;t_no<priv->track_db;t_no++){
    1894         mov_track_t* trak=priv->tracks[t_no];
    1895         int len=(trak->samplesize) ? trak->chunks_size : trak->samples_size;
    1896         if(demuxer->a_streams[t_no]){ // need audio
    1897             if(len>best_a_len){ best_a_len=len; best_a_id=t_no; }
    1898         }
    1899         if(demuxer->v_streams[t_no]){ // need video
    1900             if(len>best_v_len){ best_v_len=len; best_v_id=t_no; }
    1901         }
    1902     }
    1903     dprintf( "MOV: longest streams: A: #%d (%d samples)  V: #%d (%d samples)\n",
    1904         best_a_id,best_a_len,best_v_id,best_v_len);
    1905     if(demuxer->audio->id==-1 && best_a_id>=0) demuxer->audio->id=best_a_id;
    1906     if(demuxer->video->id==-1 && best_v_id>=0) demuxer->video->id=best_v_id;
    1907 
    1908     // setup sh pointers:
    1909     if(demuxer->audio->id>=0){
    1910         sh_audio_t* sh=demuxer->a_streams[demuxer->audio->id];
    1911         if(sh){
    1912             demuxer->audio->sh=sh; sh->ds=demuxer->audio;
    1913         } else {
    1914             dprintf( "MOV: selected audio stream (%d) does not exists\n",demuxer->audio->id);
    1915             demuxer->audio->id=-2;
    1916         }
    1917     }
    1918     if(demuxer->video->id>=0){
    1919         sh_video_t* sh=demuxer->v_streams[demuxer->video->id];
    1920         if(sh){
    1921             demuxer->video->sh=sh; sh->ds=demuxer->video;
    1922         } else {
    1923             dprintf( "MOV: selected video stream (%d) does not exists\n",demuxer->video->id);
    1924             demuxer->video->id=-2;
    1925         }
    1926     }
    1927 
    1928     if(demuxer->video->id<0 && demuxer->audio->id<0) {
    1929         /* No AV streams found. Try to find an MPEG stream. */
    1930         for(t_no=0;t_no<priv->track_db;t_no++){
    1931             mov_track_t* trak=priv->tracks[t_no];
    1932             if(trak->media_handler == MOV_FOURCC('M','P','E','G')) {
    1933                 stream_t *s;
    1934                 demuxer_t *od;
    1935 
    1936                 demuxer->video->id = t_no;
    1937                 s = new_ds_stream(demuxer->video);
    1938                 od = demux_open(s, DEMUXER_TYPE_MPEG_PS, -1, -1, -1, NULL);
    1939                 if(od) return new_demuxers_demuxer(od, od, od);
    1940                 demuxer->video->id = -2;        //new linked demuxer couldn't be allocated
    1941                 break;
    1942             }
    1943         }
    1944     }
    1945 
    1946 #if 0
    1947     if( mp_msg_test(MSGL_DBG3) ){
    1948         for(t_no=0;t_no<priv->track_db;t_no++){
    1949             mov_track_t* trak=priv->tracks[t_no];
    1950             if(trak->type==MOV_TRAK_GENERIC){
    1951                 int i;
    1952                 int fd;
    1953                 char name[20];
    1954                 dprintf( "MOV: Track #%d: Extracting %d data chunks to files\n",t_no,trak->samples_size);
    1955                 for (i=0; i<trak->samples_size; i++)
    1956                 {
    1957                     int len=trak->samples[i].size;
    1958                     char buf[len];
    1959                     stream_seek(demuxer->stream, trak->samples[i].pos);
    1960                     snprintf(name, 20, "t%02d-s%03d.%s", t_no,i,
    1961                         (trak->media_handler==MOV_FOURCC('f','l','s','h')) ?
    1962                             "swf":"dump");
    1963                     fd = open(name, O_CREAT|O_WRONLY);
    1964 //                  { int j;
    1965 //                      for(j=0;j<trak->stdata_len-3; j++)
    1966 //                          printf("stdata[%d]=0x%X ize=0x%X\n",j,char2int(trak->stdata,j),MOV_FOURCC('z','l','i','b'));
    1967 //                  }
    1968                     if( //trak->media_handler==MOV_FOURCC('s','p','r','t') &&
    1969                         trak->stdata_len>=16 &&
    1970                         char2int(trak->stdata,12)==MOV_FOURCC('z','l','i','b')
    1971                     ){
    1972                         int newlen=stream_read_dword(demuxer->stream);
    1973 #ifdef HAVE_ZLIB
    1974                         // unzip:
    1975                         z_stream zstrm;
    1976                         int zret;
    1977                         char buf2[newlen];
    1978 
    1979                         len-=4;
    1980                         stream_read(demuxer->stream, buf, len);
    1981 
    1982                         zstrm.zalloc          = (alloc_func)0;
    1983                         zstrm.zfree           = (free_func)0;
    1984                         zstrm.opaque          = (voidpf)0;
    1985                         zstrm.next_in         = buf;
    1986                         zstrm.avail_in        = len;
    1987                         zstrm.next_out        = buf2;
    1988                         zstrm.avail_out       = newlen;
    1989 
    1990                         zret = inflateInit(&zstrm);
    1991                         zret = inflate(&zstrm, Z_NO_FLUSH);
    1992                         if(newlen != zstrm.total_out)
    1993                             dprintf( "Warning! unzipped frame size differs hdr: %d  zlib: %ld\n",newlen,zstrm.total_out);
    1994 
    1995                         write(fd, buf2, newlen);
    1996                     } else {
    1997 #else
    1998                         len-=4;
    1999                         dprintf( "******* ZLIB COMPRESSED SAMPLE!!!!! (%d->%d bytes) *******\n",len,newlen);
    2000                     }
    2001                     {
    2002 #endif
    2003                         stream_read(demuxer->stream, buf, len);
    2004                         write(fd, buf, len);
    2005                     }
    2006                     close(fd);
    2007                 }
    2008             }
    2009         }
    2010     }
    2011     demuxer->stream->eof = 0;
    2012 #endif
    2013 
    2014     return demuxer;
    2015 }
    2016 
    2017 /**
    2018  * \brief return the mov track that belongs to a demuxer stream
    2019  * \param ds the demuxer stream, may be NULL
    2020  * \return the mov track info structure belonging to the stream,
    2021  *          NULL if not found
    2022  */
    2023 static mov_track_t *stream_track(mov_priv_t *priv, demux_stream_t *ds) {
    2024   if (ds && (ds->id >= 0) && (ds->id < priv->track_db))
    2025     return priv->tracks[ds->id];
    2026   return NULL;
    2027 }
    2028 
    2029 // return value:
    2030 //     0 = EOF or no stream found
    2031 //     1 = successfully read a packet
    2032 static int demux_mov_fill_buffer(demuxer_t *demuxer,demux_stream_t* ds){
    2033     mov_priv_t* priv=demuxer->priv;
    2034     mov_track_t* trak=NULL;
    2035     float pts;
    2036     int x;
    2037     off_t pos;
    2038 
    2039     if (ds->eof) return 0;
    2040     trak = stream_track(priv, ds);
    2041     if (!trak) return 0;
    2042 
    2043 if(trak->samplesize){
    2044     // read chunk:
    2045     if(trak->pos>=trak->chunks_size) return 0; // EOF
    2046     stream_seek(demuxer->stream,trak->chunks[trak->pos].pos);
    2047     pts=(float)(trak->chunks[trak->pos].sample*trak->duration)/(float)trak->timescale;
    2048     if(trak->samplesize!=1)
    2049     {
    2050         dprintf( "WARNING! Samplesize(%d) != 1\n",
    2051                 trak->samplesize);
    2052         if((trak->fourcc != MOV_FOURCC('t','w','o','s')) && (trak->fourcc != MOV_FOURCC('s','o','w','t')))
    2053             x=trak->chunks[trak->pos].size*trak->samplesize;
    2054         else
    2055             x=trak->chunks[trak->pos].size;
    2056     }
    2057     x=trak->chunks[trak->pos].size;
    2058 //    printf("X = %d\n", x);
    2059     /* the following stuff is audio related */
    2060     if (trak->type == MOV_TRAK_AUDIO){
    2061       if(trak->stdata_len>=44 && trak->stdata[9]>=1 && char2int(trak->stdata,28)>0){
    2062         // stsd version 1 - we have audio compression ratio info:
    2063         x/=char2int(trak->stdata,28); // samples/packet
    2064 //      x*=char2int(trak->stdata,32); // bytes/packet
    2065         x*=char2int(trak->stdata,36); // bytes/frame
    2066       } else {
    2067         if(ds->ss_div && ds->ss_mul){
    2068             // workaround for buggy files like 7up-high-traffic-areas.mov,
    2069             // with missing stsd v1 header containing compression rate
    2070             x/=ds->ss_div; x*=ds->ss_mul; // compression ratio fix  ! HACK !
    2071         } else {
    2072             x*=trak->nchannels;
    2073             x*=trak->samplebytes;
    2074         }
    2075       }
    2076       dprintf( "Audio sample %d bytes pts %5.3f\n",trak->chunks[trak->pos].size*trak->samplesize,pts);
    2077     } /* MOV_TRAK_AUDIO */
    2078     pos=trak->chunks[trak->pos].pos;
    2079 } else {
    2080     int frame=trak->pos;
    2081     // editlist support:
    2082     if(trak->type == MOV_TRAK_VIDEO && trak->editlist_size>=1){
    2083         // find the right editlist entry:
    2084         if(frame<trak->editlist[trak->editlist_pos].start_frame)
    2085             trak->editlist_pos=0;
    2086         while(trak->editlist_pos<trak->editlist_size-1 &&
    2087             frame>=trak->editlist[trak->editlist_pos+1].start_frame)
    2088                 ++trak->editlist_pos;
    2089         if(frame>=trak->editlist[trak->editlist_pos].start_frame+
    2090             trak->editlist[trak->editlist_pos].frames) return 0; // EOF
    2091         // calc real frame index:
    2092         frame-=trak->editlist[trak->editlist_pos].start_frame;
    2093         frame+=trak->editlist[trak->editlist_pos].start_sample;
    2094         // calc pts:
    2095         pts=(float)(trak->samples[frame].pts+
    2096             trak->editlist[trak->editlist_pos].pts_offset)/(float)trak->timescale;
    2097     } else {
    2098         if(frame>=trak->samples_size) return 0; // EOF
    2099         pts=(float)trak->samples[frame].pts/(float)trak->timescale;
    2100     }
    2101     // read sample:
    2102     stream_seek(demuxer->stream,trak->samples[frame].pos);
    2103     x=trak->samples[frame].size;
    2104     pos=trak->samples[frame].pos;
    2105 }
    2106 if(trak->pos==0 && trak->stream_header_len>0){
    2107     // we have to append the stream header...
    2108     demux_packet_t* dp=new_demux_packet(x+trak->stream_header_len);
    2109     memcpy(dp->buffer,trak->stream_header,trak->stream_header_len);
    2110     stream_read(demuxer->stream,dp->buffer+trak->stream_header_len,x);
    2111     free(trak->stream_header);
    2112     trak->stream_header = NULL;
    2113     trak->stream_header_len = 0;
    2114     dp->pts=pts;
    2115     dp->flags=0;
    2116     dp->pos=pos; // FIXME?
    2117     ds_add_packet(ds,dp);
    2118 } else
    2119     ds_read_packet(ds,demuxer->stream,x,pts,pos,0);
    2120 
    2121     ++trak->pos;
    2122 
    2123     return 1;
    2124 
    2125 }
    2126 
    2127 static float mov_seek_track(mov_track_t* trak,float pts,int flags){
    2128 
    2129 //    printf("MOV track seek called  %5.3f  \n",pts);
    2130     if(flags&2) pts*=trak->length; else pts*=(float)trak->timescale;
    2131 
    2132 if(trak->samplesize){
    2133     int sample=pts/trak->duration;
    2134 //    printf("MOV track seek - chunk: %d  (pts: %5.3f  dur=%d)  \n",sample,pts,trak->duration);
    2135     if(!(flags&1)) sample+=trak->chunks[trak->pos].sample; // relative
    2136     trak->pos=0;
    2137     while(trak->pos<trak->chunks_size && trak->chunks[trak->pos].sample<sample) ++trak->pos;
    2138     if (trak->pos == trak->chunks_size) return -1;
    2139     pts=(float)(trak->chunks[trak->pos].sample*trak->duration)/(float)trak->timescale;
    2140 } else {
    2141     unsigned int ipts;
    2142     if(!(flags&1)) pts+=trak->samples[trak->pos].pts;
    2143     if(pts<0) pts=0;
    2144     ipts=pts;
    2145     //printf("MOV track seek - sample: %d  \n",ipts);
    2146     for(trak->pos=0;trak->pos<trak->samples_size;++trak->pos){
    2147         if(trak->samples[trak->pos].pts>=ipts) break; // found it!
    2148     }
    2149     if (trak->pos == trak->samples_size) return -1;
    2150     if(trak->keyframes_size){
    2151         // find nearest keyframe
    2152         int i;
    2153         for(i=0;i<trak->keyframes_size;i++){
    2154             if(trak->keyframes[i]>=trak->pos) break;
    2155         }
    2156         if (i == trak->keyframes_size) return -1;
    2157         if(i>0 && (trak->keyframes[i]-trak->pos) > (trak->pos-trak->keyframes[i-1]))
    2158           --i;
    2159         trak->pos=trak->keyframes[i];
    2160 //      printf("nearest keyframe: %d  \n",trak->pos);
    2161     }
    2162     pts=(float)trak->samples[trak->pos].pts/(float)trak->timescale;
    2163 }
    2164 
    2165 //    printf("MOV track seek done:  %5.3f  \n",pts);
    2166 
    2167 return pts;
    2168 }
    2169 
    2170 static void demux_seek_mov(demuxer_t *demuxer,float pts,int flags){
    2171     mov_priv_t* priv=demuxer->priv;
    2172     demux_stream_t* ds;
    2173     mov_track_t* trak;
    2174 
    2175 //    printf("MOV seek called  %5.3f  flag=%d  \n",pts,flags);
    2176 
    2177     ds=demuxer->video;
    2178     trak = stream_track(priv, ds);
    2179     if (trak) {
    2180         //if(flags&2) pts*=(float)trak->length/(float)trak->timescale;
    2181         //if(!(flags&1)) pts+=ds->pts;
    2182         ds->pts=mov_seek_track(trak,pts,flags);
    2183         if (ds->pts < 0) ds->eof = 1;
    2184         else pts = ds->pts;
    2185         flags=1; // absolute seconds
    2186     }
    2187 
    2188     ds=demuxer->audio;
    2189     trak = stream_track(priv, ds);
    2190     if (trak) {
    2191         //if(flags&2) pts*=(float)trak->length/(float)trak->timescale;
    2192         //if(!(flags&1)) pts+=ds->pts;
    2193         ds->pts=mov_seek_track(trak,pts,flags);
    2194         if (ds->pts < 0) ds->eof = 1;
    2195         if (demuxer->video->id < 0)
    2196           ((sh_audio_t*)ds->sh)->delay = ds->pts;
    2197     }
    2198 
    2199 }
    2200 
    2201 static int demux_mov_control(demuxer_t *demuxer, int cmd, void *arg){
    2202   mov_track_t* track;
    2203 
    2204   // try the video track
    2205   track = stream_track(demuxer->priv, demuxer->video);
    2206   if (!track || !track->length)
    2207     // otherwise try to get the info from the audio track
    2208     track = stream_track(demuxer->priv, demuxer->audio);
    2209 
    2210   if (!track || !track->length)
    2211     return DEMUXER_CTRL_DONTKNOW;
    2212 
    2213   switch(cmd) {
    2214     case DEMUXER_CTRL_GET_TIME_LENGTH:
    2215       if (!track->timescale)
    2216         return DEMUXER_CTRL_DONTKNOW;
    2217       *((double *)arg) = (double)track->length / track->timescale;
    2218       return DEMUXER_CTRL_OK;
    2219 
    2220     case DEMUXER_CTRL_GET_PERCENT_POS:
    2221       {
    2222         off_t pos = track->pos;
    2223         if (track->durmap_size >= 1)
    2224           pos *= track->durmap[0].dur;
    2225         *((int *)arg) = (int)(100 * pos / track->length);
    2226         return DEMUXER_CTRL_OK;
    2227       }
    2228   }
    2229   return DEMUXER_CTRL_NOTIMPL;
    2230 }
    2231 
    2232 
    2233 demuxer_desc_t demuxer_desc_mov = {
    2234   "Quicktime/MP4 demuxer",
    2235   "mov",
    2236   "Quicktime/MOV",
    2237   "Arpi, Al3x, Atmos, others",
    2238   "Handles Quicktime, MP4, 3GP",
    2239   DEMUXER_TYPE_MOV,
    2240   0, // slow autodetect
    2241   mov_check_file,
    2242   demux_mov_fill_buffer,
    2243   mov_read_header,
    2244   demux_close_mov,
    2245   demux_seek_mov,
    2246   demux_mov_control
    2247 };
     2310
     2311
     2312    demuxer_desc_t demuxer_desc_mov = {
     2313        "Quicktime/MP4 demuxer",
     2314        "mov",
     2315        "Quicktime/MOV",
     2316        "Arpi, Al3x, Atmos, others",
     2317        "Handles Quicktime, MP4, 3GP",
     2318        DEMUXER_TYPE_MOV,
     2319        1, // slow autodetect
     2320        mov_check_file,
     2321        demux_mov_fill_buffer,
     2322        mov_read_header,
     2323        demux_close_mov,
     2324        demux_seek_mov,
     2325        demux_mov_control
     2326    };

  • TabularUnified trunk/libmpdemux/demux_mpg.c

    r249 r263  
    305305                if(!demux->s_streams[aid]){
    306306                    dprintf("Found subtitle: %d \n",aid);
    307                     demux->s_streams[aid]=1;
     307                    new_sh_sub(demux, aid);
    308308                }
    309309                if(demux->sub->id > -1)

  • TabularUnified trunk/libmpdemux/demux_ogg.c

    r260 r263  
    516516            }
    517517            // check for -slang if subs are uninitialized yet
    518             if (os->text && d->sub->id == -1 && demux_ogg_check_lang(val, dvdsub_lang))
     518            if (os->text && d->sub->id < 0 && demux_ogg_check_lang(val, dvdsub_lang))
    519519            {
    520                 d->sub->id = id;
     520                d->sub->id = index;
    521521                //dvdsub_id = index;
    522522                dprintf("Ogg demuxer: Displaying subtitle stream id %d which matched -slang %s\n", id, val);
    … …  
    568568    }
    569569    if (os->text) {
    570         if (id == d->sub->id) // don't want to add subtitles to the demuxer for now
     570        if (id == demux_ogg_sub_id(d, d->sub->id)) // don't want to add subtitles to the demuxer for now
    571571            demux_ogg_add_sub(os,pack);
    572572        return 0;
    … …  
    748748/* defined in demux_mov.c */
    749749extern unsigned int store_ughvlc(unsigned char *s, unsigned int v);
    750 
    751 /** \brief Return the number of subtitle tracks in the file.
    752 
    753 \param demuxer The demuxer for which the number of subtitle tracks
    754 should be returned.
    755 */
    756 int demux_ogg_num_subs(demuxer_t *demuxer) {
    757     ogg_demuxer_t *ogg_d = (ogg_demuxer_t *)demuxer->priv;
    758     return ogg_d->n_text;
    759 }
    760750
    761751/** \brief Change the current subtitle stream and return its ID.
    … …  
    12151205                ogg_d->subs[ogg_d->num_sub].samplerate= get_uint64(&st->time_unit)/10;
    12161206                ogg_d->subs[ogg_d->num_sub].text = 1;
    1217                 if (identify)
    1218                     dprintf("ID_SUBTITLE_ID=%d\n", ogg_d->n_text);
    12191207                ogg_d->subs[ogg_d->num_sub].id = ogg_d->n_text;
    12201208                if (demuxer->sub->id == ogg_d->n_text)
    12211209                    text_id = ogg_d->num_sub;
    12221210                ogg_t_table[ogg_d->n_text] = s_no;
     1211                new_sh_sub(demuxer, ogg_d->n_text);
    12231212                ogg_d->n_text++;
    12241213                ogg_d->text_ids = (int *)realloc(ogg_d->text_ids, sizeof(int) * ogg_d->n_text);

  • TabularUnified trunk/libmpdemux/demux_rawaudio.c

    r64 r263  
    2424static int samplesize = 2;
    2525static int format = 0x1; // Raw PCM
    26 
     26static int bitrate = 0;
    2727
    2828
    … …  
    3636    w->nChannels = sh_audio->channels = channels;
    3737    w->nSamplesPerSec = sh_audio->samplerate = samplerate;
    38     w->nAvgBytesPerSec = samplerate*samplesize*channels;
     38    if (bitrate > 999)
     39        w->nAvgBytesPerSec = bitrate/8;
     40    else if (bitrate > 0)
     41        w->nAvgBytesPerSec = bitrate*125;
     42    else
     43        w->nAvgBytesPerSec = samplerate*samplesize*channels;
    3944    w->nBlockAlign = channels*samplesize;
    4045    sh_audio->samplesize = samplesize;
    … …  
    6469    dp->pts = (spos - demuxer->movi_start)  / (float)(sh_audio->wf->nAvgBytesPerSec);
    6570    dp->pos = (spos - demuxer->movi_start);
    66 
    6771    l = stream_read(demuxer->stream,dp->buffer,l);
    6872    resize_demux_packet(dp, l);

  • TabularUnified trunk/libmpdemux/demux_real.c

    r262 r263  
    15291529
    15301530                            /* emulate BITMAPINFOHEADER */
    1531                             sh->bih = malloc(sizeof(BITMAPINFOHEADERw)+16);
    1532                             memset(sh->bih, 0, sizeof(BITMAPINFOHEADERw)+16);
    1533                             sh->bih->biSize = 48;
     1531                            sh->bih = malloc(sizeof(BITMAPINFOHEADERw));
     1532                            memset(sh->bih, 0, sizeof(BITMAPINFOHEADERw));
     1533                            sh->bih->biSize = sizeof(BITMAPINFOHEADERw);
    15341534                            sh->disp_w = sh->bih->biWidth = stream_read_word(demuxer->stream);
    15351535                            sh->disp_h = sh->bih->biHeight = stream_read_word(demuxer->stream);
    … …  
    15621562                            stream_skip(demuxer->stream, 2);
    15631563
    1564                             // read codec sub-format (to make difference between low and high rate codec)
    1565                             ((unsigned int*)(sh->bih+1))[0]=stream_read_dword(demuxer->stream);
    1566 
    1567                             /* h263 hack */
    1568                             tmp = stream_read_dword(demuxer->stream);
    1569                             ((unsigned int*)(sh->bih+1))[1]=tmp;
    1570                             dprintf("H.263 ID: %x\n", tmp);
    1571                             switch (tmp)
    15721564                            {
    1573                             case 0x10000000:
    1574                                 /* sub id: 0 */
    1575                                 /* codec id: rv10 */
    1576                                 break;
    1577                             case 0x10003000:
    1578                             case 0x10003001:
    1579                                 /* sub id: 3 */
    1580                                 /* codec id: rv10 */
    1581                                 sh->bih->biCompression = sh->format = mmioFOURCC('R', 'V', '1', '3');
    1582                                 break;
    1583                             case 0x20001000:
    1584                             case 0x20100001:
    1585                             case 0x20200002:
    1586                                 /* codec id: rv20 */
    1587                                 break;
    1588                             case 0x30202002:
    1589                                 /* codec id: rv30 */
    1590                                 break;
    1591                             case 0x40000000:
    1592                                 /* codec id: rv40 */
    1593                                 break;
    1594                             default:
    1595                                 /* codec id: none */
    1596                                 dprintf("unknown id: %x\n", tmp);
    1597                             }
    1598                             if((sh->format<=0x30335652) && (tmp>=0x20200002)){
    1599                                 // read data for the cmsg24[] (see vd_realvid.c)
     1565                                // read and store codec extradata
    16001566                                unsigned int cnt = codec_data_size - (stream_tell(demuxer->stream) - codec_pos);
    1601                                 if (cnt < 2) {
    1602                                     dprintf("realvid: cmsg24 data too short (size %u)\n", cnt);
     1567                                if (cnt > 0x7fffffff - sizeof(BITMAPINFOHEADERw)) {
     1568                                    dprintf("Extradata too big (%u)\n", cnt);
    16031569                                } else  {
    1604                                     int ii;
    1605                                     if (cnt > 8) {
    1606                                         dprintf("realvid: cmsg24 data too big, please report (size %u)\n", cnt);
    1607                                         cnt = 8;
    1608                                     }
    1609                                     for (ii = 0; ii < cnt; ii++)
    1610                                         ((unsigned char*)(sh->bih+1))[8+ii]=(unsigned short)stream_read_char(demuxer->stream);
     1570                                    sh->bih = realloc(sh->bih, sizeof(BITMAPINFOHEADERw) + cnt);
    16111571                                    sh->bih->biSize += cnt;
     1572                                    stream_read(demuxer->stream, ((unsigned char*)(sh->bih+1)), cnt);
    16121573                                }
    16131574                            }
     1575                            if(sh->format == 0x30315652 && ((unsigned char*)(sh->bih+1))[6] == 0x30)
     1576                                sh->bih->biCompression = sh->format = mmioFOURCC('R', 'V', '1', '3');
    16141577                            /* Select video stream with highest bitrate if multirate file*/
    16151578                            if (priv->is_multirate && ((demuxer->video->id == -1) ||

  • TabularUnified trunk/libmpdemux/demux_ts.c

    r260 r263  
    233233    int keep_broken;
    234234    int last_aid;
     235    int last_vid;
    235236    char packet[TS_FEC_PACKET_SIZE];
    236237    TS_stream_info vstr, astr;
    … …  
    382383    dprintf("GOOD CC: %d, BAD CC: %d\n", good, bad);
    383384
    384     //  if(good >= bad)
    385     return size;
    386     //  else
    387     return 0;
     385    if(good >= bad)
     386        return size;
     387    else
     388        return 0;
    388389}
    389390
    … …  
    934935        ES_stream_t *es = priv->ts.pids[params.vpid];
    935936        sh_video = new_sh_video_vid(demuxer, 0, es->pid);
     937        priv->ts.streams[params.vpid].id = 0;
     938        priv->ts.streams[params.vpid].sh = sh_video;
     939        priv->ts.streams[params.vpid].type = TYPE_VIDEO;
     940        priv->last_vid = 0;
     941        demuxer->video->id = 0;
     942
    936943        if(params.vtype == VIDEO_AVC && es->extradata && es->extradata_len)
    937944        {
    … …  
    27012708            }
    27022709
     2710            if((IS_VIDEO(tss->type) || IS_VIDEO(tss->subtype)) && is_start && !priv->ts.streams[pid].sh && priv->last_vid+1 < MAX_V_STREAMS)
     2711            {
     2712                sh_video_t *sh = new_sh_video_vid(demuxer, priv->last_vid+1, pid);
     2713                if(sh)
     2714                {
     2715                    sh->format = IS_VIDEO(tss->type) ? tss->type : tss->subtype;
     2716                    sh->ds = demuxer->video;
     2717
     2718                    priv->last_vid++;
     2719                    priv->ts.streams[pid].id = priv->last_vid;
     2720                    priv->ts.streams[pid].sh = sh;
     2721                    priv->ts.streams[pid].type = TYPE_VIDEO;
     2722                    dprintf("\r\nADDED VIDEO PID %d, type: %x stream n. %d\r\n", pid, sh->format, priv->last_vid);
     2723                }
     2724            }
    27032725
    27042726            if((pid == demuxer->sub->id))       //or the lang is right
    … …  
    27072729            }
    27082730
    2709             if(is_video && (demuxer->video->id == tss->pid))
     2731            if(is_video && (demuxer->video->id == priv->ts.streams[pid].id))
    27102732            {
    27112733                ds = demuxer->video;
    … …  
    31333155}
    31343156
     3157static int is_usable_program(ts_priv_t *priv, pmt_t *pmt)
     3158{
     3159    int j;
     3160
     3161    for(j = 0; j < pmt->es_cnt; j++)
     3162    {
     3163        if(priv->ts.pids[pmt->es[j].pid] == NULL || priv->ts.streams[pmt->es[j].pid].sh == NULL)
     3164            continue;
     3165        if(
     3166           priv->ts.streams[pmt->es[j].pid].type == TYPE_VIDEO ||
     3167           priv->ts.streams[pmt->es[j].pid].type == TYPE_AUDIO
     3168          )
     3169            return 1;
     3170    }
     3171
     3172    return 0;
     3173}
     3174
    31353175static int demux_ts_control(demuxer_t *demuxer, int cmd, void *arg)
    31363176{
    … …  
    31403180    {
    31413181    case DEMUXER_CTRL_SWITCH_AUDIO:
    3142         {
    3143             sh_audio_t *sh_audio = demuxer->audio->sh;
    3144             sh_audio_t *sh_a = NULL;
     3182    case DEMUXER_CTRL_SWITCH_VIDEO:
     3183        {
     3184            void *sh = NULL;
    31453185            int i, n;
    3146             if(!sh_audio)
    3147                 return DEMUXER_CTRL_NOTIMPL;
    3148 
     3186            int reftype, areset = 0, vreset = 0;
     3187            demux_stream_t *ds;
     3188
     3189            if(cmd == DEMUXER_CTRL_SWITCH_VIDEO)
     3190            {
     3191                reftype = TYPE_VIDEO;
     3192                ds = demuxer->video;
     3193                vreset  = 1;
     3194            }
     3195            else
     3196            {
     3197                reftype = TYPE_AUDIO;
     3198                ds = demuxer->audio;
     3199                areset = 1;
     3200            }
    31493201            n = *((int*)arg);
     3202            if(n == -2)
     3203            {
     3204                reset_fifos(priv, areset, vreset, 0);
     3205                ds->id = -2;
     3206                ds->sh = NULL;
     3207                ds_free_packs(ds);
     3208                *((int*)arg) = ds->id;
     3209                return DEMUXER_CTRL_OK;
     3210            }
     3211
    31503212            if(n < 0)
    31513213            {
    31523214                for(i = 0; i < 8192; i++)
    31533215                {
    3154                     if(priv->ts.streams[i].id == demuxer->audio->id && priv->ts.streams[i].type == TYPE_AUDIO)
     3216                    if(priv->ts.streams[i].id == ds->id && priv->ts.streams[i].type == reftype)
    31553217                        break;
    31563218                }
    31573219
    3158                 while(!sh_a)
     3220                while(!sh)
    31593221                {
    31603222                    i = (i+1) % 8192;
    3161                     if(priv->ts.streams[i].id == demuxer->audio->id)    //we made a complete loop
    3162                         break;
    3163                     if(priv->ts.streams[i].type == TYPE_AUDIO)
    3164                         sh_a = (sh_audio_t*)priv->ts.streams[i].sh;
     3223                    if(priv->ts.streams[i].type == reftype)
     3224                    {
     3225                        if(priv->ts.streams[i].id == ds->id)    //we made a complete loop
     3226                            break;
     3227                        sh = priv->ts.streams[i].sh;
     3228                    }
    31653229                }
    31663230            }
    … …  
    31693233                for(i = 0; i < 8192; i++)
    31703234                {
    3171                     if(priv->ts.streams[i].id == n && priv->ts.streams[i].type == TYPE_AUDIO)
     3235                    if(priv->ts.streams[i].id == n && priv->ts.streams[i].type == reftype)
    31723236                    {
    3173                         sh_a = (sh_audio_t*)priv->ts.streams[i].sh;
     3237                        sh = priv->ts.streams[i].sh;
    31743238                        break;
    31753239                    }
    … …  
    31773241            }
    31783242
    3179             if(sh_a)
    3180             {
    3181                 demuxer->audio->id = priv->ts.streams[i].id;
    3182                 demuxer->audio->sh = sh_a;
    3183                 ds_free_packs(demuxer->audio);
    3184                 dprintf("\r\ndemux_ts, switched to audio pid %d, id: %d, sh: %p\r\n", i, demuxer->audio->id, sh_a);
    3185             }
    3186 
    3187             *((int*)arg) = demuxer->audio->id;
     3243            if(sh)
     3244            {
     3245                if(ds->id != priv->ts.streams[i].id)
     3246                    reset_fifos(priv, areset, vreset, 0);
     3247                ds->id = priv->ts.streams[i].id;
     3248                ds->sh = sh;
     3249                ds_free_packs(ds);
     3250                dprintf("\r\ndemux_ts, switched to audio pid %d, id: %d, sh: %p\r\n", i, ds->id, sh);
     3251            }
     3252
     3253            *((int*)arg) = ds->id;
    31883254            return DEMUXER_CTRL_OK;
    31893255        }
    31903256
     3257    case DEMUXER_CTRL_IDENTIFY_PROGRAM:         //returns in prog->{aid,vid} the new ids that comprise a program
     3258        {
     3259            int i, j, cnt=0;
     3260            int vid_done=0, aid_done=0;
     3261            pmt_t *pmt = NULL;
     3262            demux_program_t *prog = arg;
     3263
     3264            if(priv->pmt_cnt < 2)
     3265                return DEMUXER_CTRL_NOTIMPL;
     3266
     3267            if(prog->progid == -1)
     3268            {
     3269                int cur_pmt_idx = 0;
     3270
     3271                for(i = 0; i < priv->pmt_cnt; i++)
     3272                    if(priv->pmt[i].progid == priv->prog)
     3273                    {
     3274                        cur_pmt_idx = i;
     3275                        break;
     3276                    }
     3277
     3278                i = (cur_pmt_idx + 1) % priv->pmt_cnt;
     3279                while(i != cur_pmt_idx)
     3280                {
     3281                    pmt = &priv->pmt[i];
     3282                    cnt = is_usable_program(priv, pmt);
     3283                    if(cnt)
     3284                        break;
     3285                    i = (i + 1) % priv->pmt_cnt;
     3286                }
     3287            }
     3288            else
     3289            {
     3290                for(i = 0; i < priv->pmt_cnt; i++)
     3291                    if(priv->pmt[i].progid == prog->progid)
     3292                    {
     3293                        pmt = &priv->pmt[i]; //required program
     3294                        cnt = is_usable_program(priv, pmt);
     3295                    }
     3296            }
     3297
     3298            if(!cnt)
     3299                return DEMUXER_CTRL_NOTIMPL;
     3300
     3301            //finally some food
     3302            prog->aid = prog->vid = -2; //no audio and no video by default
     3303            for(j = 0; j < pmt->es_cnt; j++)
     3304            {
     3305                if(priv->ts.pids[pmt->es[j].pid] == NULL || priv->ts.streams[pmt->es[j].pid].sh == NULL)
     3306                    continue;
     3307
     3308                if(!vid_done && priv->ts.streams[pmt->es[j].pid].type == TYPE_VIDEO)
     3309                {
     3310                    vid_done = 1;
     3311                    prog->vid = priv->ts.streams[pmt->es[j].pid].id;
     3312                }
     3313                else if(!aid_done && priv->ts.streams[pmt->es[j].pid].type == TYPE_AUDIO)
     3314                {
     3315                    aid_done = 1;
     3316                    prog->aid = priv->ts.streams[pmt->es[j].pid].id;
     3317                }
     3318            }
     3319
     3320            priv->prog = prog->progid = pmt->progid;
     3321            return DEMUXER_CTRL_OK;
     3322        }
    31913323
    31923324    default:

  • TabularUnified trunk/libmpdemux/demuxer.c

    r262 r263  
    8181
    8282demuxer_desc_t* demuxer_list[] = {
     83    &demuxer_desc_lavf,
    8384    &demuxer_desc_rawaudio,
    8485    //    &demuxer_desc_rawvideo,
    … …  
    8788#endif
    8889    //    &demuxer_desc_mf,
    89     &demuxer_desc_avi,
     90    //&demuxer_desc_avi,
    9091    //    &demuxer_desc_y4m,
    9192    &demuxer_desc_asf,
    … …  
    111112    //    &demuxer_desc_pva,
    112113    //    &demuxer_desc_lmlm4,
    113     &demuxer_desc_audio,
    114114    &demuxer_desc_mpeg_ps,
    115115    &demuxer_desc_mpeg_pes,
    … …  
    118118    &demuxer_desc_mpeg4_es,
    119119    &demuxer_desc_h264_es,
    120     &demuxer_desc_mpeg_ts,
     120    //&demuxer_desc_mpeg_ts,
    121121    &demuxer_desc_mpeg_ty,
     122    &demuxer_desc_audio,
    122123#ifdef HAVE_LIBDV095
    123124    &demuxer_desc_rawdv,
    … …  
    129130    &demuxer_desc_rtp,
    130131#endif
    131     &demuxer_desc_lavf,
    132132    //    &demuxer_desc_aac,
    133133    NULL
    … …  
    214214}
    215215
     216sh_sub_t *new_sh_sub_sid(demuxer_t *demuxer, int id, int sid) {
     217    if (id > MAX_S_STREAMS - 1 || id < 0) {
     218        dprintf("Requested sub stream id overflow (%d > %d)\n",
     219                id, MAX_S_STREAMS);
     220        return NULL;
     221    }
     222    if (demuxer->s_streams[id])
     223        dprintf("Sub stream %i redefined\n", id);
     224    else {
     225        sh_sub_t *sh = calloc(1, sizeof(sh_sub_t));
     226        demuxer->s_streams[id] = sh;
     227        sh->sid = sid;
     228        dprintf("ID_SUBTITLE_ID=%d\n", sid);
     229    }
     230    return demuxer->s_streams[id];
     231}
     232
    216233sh_audio_t* new_sh_audio_aid(demuxer_t *demuxer,int id,int aid){
    217234    if(id > MAX_A_STREAMS-1 || id < 0)
    … …  
    257274}
    258275
    259 void free_sh_audio(sh_audio_t* sh){
    260     dprintf("DEMUXER: freeing sh_audio at %p  \n",sh);
    261     if(sh->wf) free(sh->wf);
    262     free(sh);
    263     sh=NULL;
     276void free_sh_audio(demuxer_t *demuxer, int id) {
     277    sh_audio_t *sh = NULL;
     278    if (!demuxer)
     279        return;
     280    sh = demuxer->a_streams[id];
     281    dprintf("DEMUXER: freeing sh_audio at %p. id: %i\n",sh, id);
     282    if (sh)
     283    {
     284        if(sh->wf) free(sh->wf);
     285        free(sh);
     286    }
     287    demuxer->a_streams[id] = NULL;
    264288}
    265289
    … …  
    284308    // free streams:
    285309    for(i=0;i<MAX_A_STREAMS;i++)
    286         if(demuxer->a_streams[i]) free_sh_audio(demuxer->a_streams[i]);
     310        if(demuxer->a_streams[i]) free_sh_audio(demuxer, i);
    287311    for(i = 0; i < MAX_V_STREAMS; i++)
    288312        if(demuxer->v_streams[i]) free_sh_video(demuxer->v_streams[i]);
    … …  
    713737    int pre_buf;
    714738    demuxer_desc_t *demuxer_desc;
    715     int fformat;
     739    int fformat = 0;
    716740    int i;
    717741
    … …  
    906930    }
    907931#endif
    908     file_format = DEMUXER_TYPE_LAVF;
     932    //if (!file_format)
     933    //    file_format = DEMUXER_TYPE_LAVF;
    909934    // If somebody requested a demuxer check it
    910935    if (file_format) {
    … …  
    10811106        }
    10821107    }
     1108    if (file_format == DEMUXER_TYPE_RAWAUDIO)
     1109    {
     1110        demuxer_type = file_format;
     1111        demuxer_force = 1;
     1112    }
    10831113    vd = demux_open_stream(vs, demuxer_type ? demuxer_type : file_format,
    10841114                           demuxer_force, audio_stream ? -2 : audio_id, video_id,
    … …  
    13081338}
    13091339
     1340int demuxer_switch_video(demuxer_t *demuxer, int index){
     1341    int res = demux_control(demuxer, DEMUXER_CTRL_SWITCH_VIDEO, &index);
     1342    if (res == DEMUXER_CTRL_NOTIMPL)
     1343        index = demuxer->video->id;
     1344    return index;
     1345}
     1346
    13101347int demuxer_add_chapter(demuxer_t* demuxer, const char* name, uint64_t start, uint64_t end){
    13111348    if (!demuxer) return 0;

  • TabularUnified trunk/libmpdemux/demuxer.h

    r262 r263  
    9494#define DEMUXER_CTRL_SWITCH_AUDIO 12
    9595#define DEMUXER_CTRL_RESYNC 13
     96#define DEMUXER_CTRL_SWITCH_VIDEO 14
     97#define DEMUXER_CTRL_IDENTIFY_PROGRAM 15
    9698
    9799//#define off_t long long
    … …  
    150152#define MAX_A_STREAMS 256
    151153#define MAX_V_STREAMS 256
     154#define MAX_S_STREAMS 32
    152155
    153156struct demuxer_st;
    … …  
    187190    char* name;
    188191} demux_chapter_t;
     192
     193typedef struct {
     194  int progid;        //program id
     195  int aid, vid, sid; //audio, video and subtitle id
     196} demux_program_t;
    189197
    190198typedef struct demuxer_st {
    … …  
    208216  void* a_streams[MAX_A_STREAMS]; // audio streams (sh_audio_t)
    209217  void* v_streams[MAX_V_STREAMS]; // video sterams (sh_video_t)
    210   char s_streams[32];   // dvd subtitles (flag)
     218  void *s_streams[MAX_S_STREAMS];   // dvd subtitles (flag)
    211219  demux_chapter_t* chapters;
    212220  int num_chapters;
    … …  
    365373extern int demuxer_get_percent_pos(demuxer_t *demuxer);
    366374extern int demuxer_switch_audio(demuxer_t *demuxer, int index);
     375extern int demuxer_switch_video(demuxer_t *demuxer, int index);
    367376float demux_mov_len(demuxer_t *demuxer);
    368377float demux_mpg_len(demuxer_t *d);

  • TabularUnified trunk/libmpdemux/ebml.h

    r248 r263  
    131131#define MATROSKA_ID_CHAPTERDISPLAY       0x80
    132132#define MATROSKA_ID_CHAPSTRING           0x85
     133
    133134/* IDs in the cluster master */
    134135#define MATROSKA_ID_CLUSTERTIMECODE      0xE7
    … …  
    141142#define MATROSKA_ID_REFERENCEBLOCK       0xFB
    142143
     144/* IDs in the attachments master */
     145#define MATROSKA_ID_ATTACHEDFILE         0x61A7
     146#define MATROSKA_ID_FILENAME             0x466E
     147#define MATROSKA_ID_FILEMIMETYPE         0x4660
     148#define MATROSKA_ID_FILEDATA             0x465C
     149#define MATROSKA_ID_FILEUID              0x46AE
    143150
    144151/* matroska track types */

  • TabularUnified trunk/libmpdemux/makefile

    r261 r263  
    4343
    4444INCL   = -I$(C_INCLUDE_PATH) -I.. -I..\libdvdread -I..\zlib -I..\libvorbis\include -I..\libvorbis\include\vorbis -I..\libavformat -I..\libavcodec -I..\libavutil -Ilibrtsp -Ifreesdp -Irealrtsp -I$(TOOLKIT_PATH)\h
    45 CFLAGS = $(CFLAGS) -DARCH_X86 -DUSE_DVDREAD -DHAVE_VCD -DHAVE_MATROSKA
     45CFLAGS = $(CFLAGS) -DARCH_X86 -DUSE_DVDREAD -DHAVE_VCD -DHAVE_MATROSKA -DHAVE_ZLIB
    4646
    4747.c.obj:

  • TabularUnified trunk/libmpdemux/matroska.h

    r181 r263  
    6262#define MKV_S_ASS        "S_ASS" // Deprecated
    6363
    64 typedef struct {
    65   char type;                    // t = text, v = VobSub
    66   int has_palette;              // If we have a valid palette
    67   unsigned int palette[16];     // for VobSubs
    68   int width, height;            // for VobSubs
    69   int custom_colors;
    70   unsigned int colors[4];
    71   int forced_subs_only;
    72 } mkv_sh_sub_t;
    73 
    74 int demux_mkv_num_subs(demuxer_t *demuxer);
    7564int demux_mkv_change_subs(demuxer_t *demuxer, int new_num);
     65void demux_mkv_get_audio_lang(demuxer_t *demuxer, int track_num, char *lang,
     66                            int maxlen);
    7667void demux_mkv_get_sub_lang(demuxer_t *demuxer, int track_num, char *lang,
    7768                            int maxlen);
    7869
     70#define MSGTR_MPDEMUX_MKV_ZlibInitializationFailed "[mkv] zlib initialization failed.\n"
     71#define MSGTR_MPDEMUX_MKV_ZlibDecompressionFailed "[mkv] zlib decompression failed.\n"
     72#define MSGTR_MPDEMUX_MKV_LzoInitializationFailed "[mkv] lzo initialization failed.\n"
     73#define MSGTR_MPDEMUX_MKV_LzoDecompressionFailed "[mkv] lzo decompression failed.\n"
     74#define MSGTR_MPDEMUX_MKV_TrackEncrypted "[mkv] Track number %u has been encrypted  and decryption has not yet been\n[mkv] implemented. Skipping track.\n"
     75#define MSGTR_MPDEMUX_MKV_UnknownContentEncoding "[mkv] Unknown content encoding type for track %u. Skipping track.\n"
     76#define MSGTR_MPDEMUX_MKV_UnknownCompression "[mkv] Track %u has been compressed with an unknown/unsupported compression\n[mkv] algorithm (%u). Skipping track.\n"
     77#define MSGTR_MPDEMUX_MKV_ZlibCompressionUnsupported "[mkv] Track %u was compressed with zlib but mplayer has not been compiled\n[mkv] with support for zlib compression. Skipping track.\n"
     78#define MSGTR_MPDEMUX_MKV_TrackIDName "[mkv] Track ID %u: %s (%s) \"%s\", %s\n"
     79#define MSGTR_MPDEMUX_MKV_TrackID "[mkv] Track ID %u: %s (%s), %s\n"
     80#define MSGTR_MPDEMUX_MKV_UnknownCodecID "[mkv] Unknown/unsupported CodecID (%s) or missing/bad CodecPrivate\n[mkv] data (track %u).\n"
     81#define MSGTR_MPDEMUX_MKV_FlacTrackDoesNotContainValidHeaders "[mkv] FLAC track does not contain valid headers.\n"
     82#define MSGTR_MPDEMUX_MKV_UnknownAudioCodec "[mkv] Unknown/unsupported audio codec ID '%s' for track %u or missing/faulty\n[mkv] private codec data.\n"
     83#define MSGTR_MPDEMUX_MKV_SubtitleTypeNotSupported "[mkv] Subtitle type '%s' is not supported.\n"
     84#define MSGTR_MPDEMUX_MKV_WillPlayVideoTrack "[mkv] Will play video track %u.\n"
     85#define MSGTR_MPDEMUX_MKV_NoVideoTrackFound "[mkv] No video track found/wanted.\n"
     86#define MSGTR_MPDEMUX_MKV_NoAudioTrackFound "[mkv] No audio track found/wanted.\n"
     87#define MSGTR_MPDEMUX_MKV_WillDisplaySubtitleTrack "[mkv] Will display subtitle track %u.\n"
     88#define MSGTR_MPDEMUX_MKV_NoBlockDurationForSubtitleTrackFound "[mkv] Warning: No BlockDuration for subtitle track found.\n"
     89#define MSGTR_MPDEMUX_MKV_TooManySublines "[mkv] Warning: too many sublines to render, skipping.\n"
     90#define MSGTR_MPDEMUX_MKV_TooManySublinesSkippingAfterFirst "\n[mkv] Warning: too many sublines to render, skipping after first %i.\n"
     91
    7992#endif /* __MATROSKA_H */

  • TabularUnified trunk/libmpdemux/stheader.h

    r260 r263  
    6767    double pts;     // predicted/interpolated PTS of the current frame
    6868    double i_pts;   // PTS for the _next_ I/P frame
     69    float next_frame_time;
     70    double last_pts;
    6971    // output format: (set by demuxer)
    7072    float fps;              // frames per second (set only if constant fps)
    … …  
    8789
    8890#pragma pack()
     91
     92typedef struct {
     93    int sid;
     94    char type;                    // t = text, v = VobSub, a = SSA/ASS
     95    int has_palette;              // If we have a valid palette
     96    unsigned int palette[16];     // for VobSubs
     97    int width, height;            // for VobSubs
     98    int custom_colors;
     99    unsigned int colors[4];
     100    int forced_subs_only;
     101#ifdef USE_ASS
     102    ass_track_t* ass_track;  // for SSA/ASS streams (type == 'a')
     103#endif
     104} sh_sub_t;
     105
    89106// demuxer.c:
    90107#define new_sh_audio(d, i) new_sh_audio_aid(d, i, i)
    … …  
    92109#define new_sh_video(d, i) new_sh_video_vid(d, i, i)
    93110sh_video_t* new_sh_video_vid(demuxer_t *demuxer,int id,int vid);
    94 //sh_audio_t* new_sh_audio(demuxer_t *demuxer,int id);
    95 //sh_video_t* new_sh_video(demuxer_t *demuxer,int id);
    96 void free_sh_audio(sh_audio_t *sh);
     111#define new_sh_sub(d, i) new_sh_sub_sid(d, i, i)
     112sh_sub_t *new_sh_sub_sid(demuxer_t *demuxer, int id, int sid);
     113void free_sh_audio(demuxer_t *demuxer, int id);
    97114void free_sh_video(sh_video_t *sh);
    98115

  • TabularUnified trunk/libwin32/realvid.c

    r257 r263  
    147147        if (RestoreOS2TIB)
    148148            RestoreOS2TIB();
    149         printf("wrvyuv_init passed\n");fflush(stdout);
    150149        // setup rv30 codec (codec sub-type and image dimensions):
    151150        if((sh->format<=0x30335652) && (extrahdr[1]>=0x20200002)){

  • TabularUnified trunk/plugins/uniplug.c

    r256 r263  
    129129                if (err == -EAGAIN) //
    130130                {
    131                     //printf("eagain\n");
     131                    printf("eagain\n");
    132132                    DosSleep(1);
    133133                    continue;

  • TabularUnified trunk/video/vdecode.c

    r262 r263  
    5353
    5454// ffmpeg
     55#ifndef ARCH_X86
     56#define ARCH_X86
     57#endif
     58
     59#include "..\libavutil\bswap.h"
    5560#include "avcodec.h"
    5661#include "dsputil.h"
    … …  
    598603            case mmioFOURCC('R', 'V', '3', '0'):
    599604            case mmioFOURCC('R', 'V', '4', '0'):
    600                 video_context->extradata_size= 8;
    601                 video_context->extradata = av_mallocz(video_context->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
    602                 if(sh_video->bih->biSize!=sizeof(*sh_video->bih)+8){
     605                if(sh_video->bih->biSize<sizeof(*sh_video->bih)+8){
    603606                    /* only 1 packet per frame & sub_id from fourcc */
     607                    video_context->extradata_size= 8;
     608                    video_context->extradata = av_mallocz(video_context->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
    604609                    ((uint32_t*)video_context->extradata)[0] = 0;
    605                     video_context->sub_id=
    606                         ((uint32_t*)video_context->extradata)[1] =
     610                    ((uint32_t*)video_context->extradata)[1] =
    607611                        (sh_video->format == mmioFOURCC('R', 'V', '1', '3')) ? 0x10003001 : 0x10000000;
    608612                } else {
    609613                    /* has extra slice header (demux_rm or rm->avi streamcopy) */
    610                     unsigned int* extrahdr=(unsigned int*)(sh_video->bih+1);
    611                     ((uint32_t*)video_context->extradata)[0] = be2me_32(extrahdr[0]);
    612                     video_context->sub_id= extrahdr[1];
    613                     ((uint32_t*)video_context->extradata)[1] = be2me_32(extrahdr[1]);
     614                    video_context->extradata_size = sh_video->bih->biSize-sizeof(BITMAPINFOHEADERw);
     615                    video_context->extradata = av_mallocz(video_context->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
     616                    memcpy(video_context->extradata, sh_video->bih+1, video_context->extradata_size);
    614617                }
     618                video_context->sub_id=bswap32(video_context->extradata+4);
    615619
    616620                //        printf("%X %X %d %d\n", extrahdr[0], extrahdr[1]);
    … …  
    810814                sh_video->format == mmioFOURCC('R', 'V', '4', '0') ||
    811815                sh_video->format == mmioFOURCC('R', 'V', '2', '0'))
    812                 if(sh_video->bih->biSize==sizeof(*sh_video->bih)+8)
     816                if(sh_video->bih->biSize>=sizeof(*sh_video->bih)+8){
    813817                {
    814818                    int i;
Note: See TracChangeset for help on using the changeset viewer.