Changeset 269


Ignore:
Timestamp:
Dec 4, 2006, 12:36:12 AM (18 years ago)
Author:
vladest
Message:

Fixed a couple of traps
Updated libavcodec/libavformat

Location:
trunk
Files:
72 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified trunk/audio/adecode.c

    r263 r269  
    19771977            a52_bias = 384;
    19781978
    1979             rc = a52_frame(a52_state, input_audio_buffer,&a52_flags,
     1979            rc = a52_frame(a52_state, input_audio_buffer, &a52_flags,
    19801980                           &a52_level, a52_bias);
    19811981            if (rc != 0) total_len = -1;

  • TabularUnified trunk/gui/makefile

    r265 r269  
    88!endif
    99GUI_LIB = guieng\guieng.lib
     10
    1011LIBS = ..\libvorbis\libvorbis.lib \
    1112       ..\libmpdemux\libmpdemux.lib \
    1213       ..\stream\stream.lib \
    1314       ..\libavcodec\libavcodec.lib \
     15       ..\libswscale\libswscale.lib \
    1416       ..\libavformat\avformat.lib \
    1517       ..\libavutil\avutil.lib \
    … …  
    2931       pcilib\libpci.lib \
    3032       $(GUI_LIB) \
     33       ..\objlib.lib \
    3134       $(TOOLKIT_PATH)\lib\os2386.lib
    3235
    … …  
    126129   cd ..
    127130
    128    gcc $(LFLAGS) -o $@ $(DEF_FILE) $(ALL_OBJ) $(ADD_OBJ) $(LIBS) -Zlinker "/MAP:FULL /EXEPACK:2" -lstdc++
     131   gcc $(LFLAGS) -o $@ $(DEF_FILE) $(ALL_OBJ) $(LIBS) -Zlinker "/MAP:FULL /EXEPACK:2" -lstdc++
    129132   rc -n -p -x $(PRJ).res $(PRJ).exe
    130133#-l..\membug\membug.lib -Zhigh-mem
    131134#
     135
    132136clean:
    133137   -@cd ..

  • TabularUnified trunk/gui/play.hpp

    r268 r269  
    747747            while (len > 0 && packet!=NULL)
    748748            {
    749                 if(timestamp < 0) timestamp = 0;
    750                 spudec_assemble(spudec,packet,len,timestamp);
     749                if(timestamp >= 0)
     750                    spudec_assemble(spudec,packet,len,timestamp);
    751751                len = ds_get_packet_sub(d_dvdsub,(unsigned char**)&packet);
    752752                if(len > 0)
    … …  
    755755            }
    756756        }
    757         if (spudec->image != NULL)
    758             memset(spudec->image,0,_msize(spudec->image));
    759757    }
    760758
    … …  
    11131111
    11141112    printf("Video thread started\n");fflush(stdout);
     1113    if (streamM->type == STREAMTYPE_DVDNAV && d_dvdsub)
     1114        d_dvdsub->id = 0;
    11151115
    11161116    // clear unwanted titles
    … …  
    11261126            while (len > 0 && packet!=NULL)
    11271127            {
    1128                 if(timestamp < 0) timestamp = 0;
    1129                 spudec_assemble(spudec,packet,len,timestamp);
     1128                if(timestamp >= 0)
     1129                    spudec_assemble(spudec,packet,len,timestamp);
    11301130                len = ds_get_packet_sub(d_dvdsub,(unsigned char**)&packet);
    11311131                if(len > 0)
    … …  
    11351135            }
    11361136        }
    1137         if (spudec->image != NULL)
    1138             memset(spudec->image,0,_msize(spudec->image));
    11391137    }
    11401138
    … …  
    14131411        }
    14141412#endif
    1415         //printf("cp2 %i %i. vt: %f, at: %f\n", numcadr, frame_decoded, video_time, audio_time);//fflush(stdout);
     1413        printf("cp2 %i %i. vt: %f, at: %f\n", numcadr, frame_decoded, video_time, audio_time);//fflush(stdout);
    14161414
    14171415        if ((numcadr > 0 || Step) &&
    … …  
    15181516                    //continue;
    15191517                }
    1520                 //printf("a: %f, v: %f\n", audio_time, video_time);
     1518                //printf("a: %f, v: %f\n", audio_time, video_time);fflush(stdout);
    15211519            }
    15221520
    … …  
    15541552        {
    15551553            spudec_heartbeat(spudec,(int)(90000.0f*sh_video->timer));
     1554            dprintf("sh. timer: %f\n", sh_video->timer);
    15561555            while (1)
    15571556            {
    … …  
    15651564                }
    15661565                if(len<=0 || !packet) break;
    1567                 if(timestamp < 0) timestamp = 0;
    1568                 else spudec_assemble(spudec,packet,len,timestamp);
     1566                if(timestamp >= 0)
     1567                    spudec_assemble(spudec,packet,len,timestamp);
    15691568            }
    15701569            if (spudec_changed(spudec))
    … …  
    15731572                showsubs=TRUE;
    15741573                OSDStartTimer(OSDNONE, OSD_TIMEOUT);
    1575                 //printf("spu changed..\n");fflush(stdout);
     1574                printf("spu changed..\n");fflush(stdout);
    15761575                //                    WinPostMsg(hWndShowClient,WM_COMMAND,
    15771576                //                               MPFROM2SHORT(IDM_REPAINT,0L),0L);
    15781577            }
    15791578        }
    1580 
    15811579        if (fps_rates[conf.ForceFPS].FPS == -1) // auto find FPS
    15821580        {
    … …  
    27822780        {
    27832781            if (streamM->type==STREAMTYPE_DVD)
    2784                 spudec=(spudec_handle_t *)
    2785                     spudec_new_scaled(((dvd_priv_t *)(streamM->priv))->cur_pgc->palette,
    2786                                       nww, nwh);
     2782                spudec=spudec_new_scaled(((dvd_priv_t *)(streamM->priv))->cur_pgc->palette,
     2783                                         nww, nwh);
    27872784            else
    2788                 spudec=(spudec_handle_t *)
    2789                     spudec_new_scaled(NULL, nww, nwh);
     2785                spudec=spudec_new_scaled(NULL, nww, nwh);
    27902786
    27912787            spudec_reset(spudec);
    2792             spudec->spu_changed = 0;
    27932788            get_dvd_aids(streamM);
    27942789            get_dvd_sids(streamM);

  • TabularUnified trunk/gui/spudec.c

    r64 r269  
    11/* SPUdec.c
    2  Skeleton of function spudec_process_controll() is from xine sources.
    3  Further works:
    4  LGB,... (yeah, try to improve it and insert your name here! ;-)
    5 
    6  Kim Minh Kaplan
    7  implement fragments reassembly, RLE decoding.
    8  read brightness from the IFO.
    9 
    10  For information on SPU format see <URL:http://sam.zoy.org/doc/dvd/subtitles/>
    11  and <URL:http://members.aol.com/mpucoder/DVD/spu.html>
     2   Skeleton of function spudec_process_controll() is from xine sources.
     3   Further works:
     4   LGB,... (yeah, try to improve it and insert your name here! ;-)
     5
     6   Kim Minh Kaplan
     7   implement fragments reassembly, RLE decoding.
     8   read brightness from the IFO.
     9
     10   For information on SPU format see <URL:http://sam.zoy.org/doc/dvd/subtitles/>
     11   and <URL:http://members.aol.com/mpucoder/DVD/spu.html>
    1212
    1313 */
    1414//#include "config.h"
    15 //#include "mp_msg.h"
     15#include "../stream/mp_msg.h"
    1616
    1717#include <errno.h>
    … …  
    2424//#include "libvo/video_out.h"
    2525#include "spudec.h"
    26 //#include "postproc/swscale.h"
     26#include "avutil.h"
     27#include "libswscale/swscale.h"
    2728
    2829#define MIN(a, b)       ((a)<(b)?(a):(b))
    2930
    3031/* Valid values for spu_aamode:
    31  0: none (fastest, most ugly)
    32  1: approximate
    33  2: full (slowest)
    34  3: bilinear (similiar to vobsub, fast and not too bad)
    35  4: uses swscaler gaussian (this is the only one that looks good)
     32   0: none (fastest, most ugly)
     33   1: approximate
     34   2: full (slowest)
     35   3: bilinear (similiar to vobsub, fast and not too bad)
     36   4: uses swscaler gaussian (this is the only one that looks good)
    3637 */
    3738
    … …  
    4142int sub_pos = 0;
    4243
     44typedef struct packet_t packet_t;
     45struct packet_t {
     46  unsigned char *packet;
     47  unsigned int palette[4];
     48  unsigned int alpha[4];
     49  unsigned int control_start;   /* index of start of control data */
     50  unsigned int current_nibble[2]; /* next data nibble (4 bits) to be
     51                                     processed (for RLE decoding) for
     52                                     even and odd lines */
     53  int deinterlace_oddness;      /* 0 or 1, index into current_nibble */
     54  unsigned int start_col, end_col;
     55  unsigned int start_row, end_row;
     56  unsigned int width, height, stride;
     57  unsigned int start_pts, end_pts;
     58  packet_t *next;
     59};
     60
     61typedef struct {
     62  packet_t *queue_head;
     63  packet_t *queue_tail;
     64  unsigned int global_palette[16];
     65  unsigned int orig_frame_width, orig_frame_height;
     66  unsigned char* packet;
     67  size_t packet_reserve;        /* size of the memory pointed to by packet */
     68  unsigned int packet_offset;   /* end of the currently assembled fragment */
     69  unsigned int packet_size;     /* size of the packet once all fragments are assembled */
     70  unsigned int packet_pts;      /* PTS for this packet */
     71  unsigned int palette[4];
     72  unsigned int alpha[4];
     73  unsigned int cuspal[4];
     74  unsigned int custom;
     75  unsigned int now_pts;
     76  unsigned int start_pts, end_pts;
     77  unsigned int start_col, end_col;
     78  unsigned int start_row, end_row;
     79  unsigned int width, height, stride;
     80  size_t image_size;            /* Size of the image buffer */
     81  unsigned char *image;         /* Grayscale value */
     82  unsigned char *aimage;        /* Alpha value */
     83  unsigned int scaled_frame_width, scaled_frame_height;
     84  unsigned int scaled_start_col, scaled_start_row;
     85  unsigned int scaled_width, scaled_height, scaled_stride;
     86  size_t scaled_image_size;
     87  unsigned char *scaled_image;
     88  unsigned char *scaled_aimage;
     89  int auto_palette; /* 1 if we lack a palette and must use an heuristic. */
     90  int font_start_level;  /* Darkest value used for the computed font */
     91  //vo_functions_t *hw_spu;
     92  int spu_changed;
     93  unsigned int forced_subs_only;     /* flag: 0=display all subtitle, !0 display only forced subtitles */
     94  unsigned int is_forced_sub;         /* true if current subtitle is a forced subtitle */
     95} spudec_handle_t;
    4396
    4497static void spudec_queue_packet(spudec_handle_t *this, packet_t *packet)
    4598{
    46     if (this->queue_head == NULL)
    47         this->queue_head = packet;
    48     else
    49         this->queue_tail->next = packet;
    50     this->queue_tail = packet;
     99  if (this->queue_head == NULL)
     100    this->queue_head = packet;
     101  else
     102    this->queue_tail->next = packet;
     103  this->queue_tail = packet;
    51104}
    52105
    53106static packet_t *spudec_dequeue_packet(spudec_handle_t *this)
    54107{
    55     packet_t *retval = this->queue_head;
    56 
    57     this->queue_head = retval->next;
    58     if (this->queue_head == NULL)
    59         this->queue_tail = NULL;
    60 
    61     return retval;
     108  packet_t *retval = this->queue_head;
     109
     110  this->queue_head = retval->next;
     111  if (this->queue_head == NULL)
     112    this->queue_tail = NULL;
     113
     114  return retval;
    62115}
    63116
    64117static void spudec_free_packet(packet_t *packet)
    65118{
    66     if (packet->packet != NULL)
    67         free(packet->packet);
    68     free(packet);
     119  if (packet->packet != NULL)
     120    free(packet->packet);
     121  free(packet);
    69122}
    70123
    71124static inline unsigned int get_be16(const unsigned char *p)
    72125{
    73     return (p[0] << 8) + p[1];
     126  return (p[0] << 8) + p[1];
    74127}
    75128
    76129static inline unsigned int get_be24(const unsigned char *p)
    77130{
    78     return (get_be16(p) << 8) + p[2];
     131  return (get_be16(p) << 8) + p[2];
    79132}
    80133
    81134static void next_line(packet_t *packet)
    82135{
    83     if (packet->current_nibble[packet->deinterlace_oddness] % 2)
    84         packet->current_nibble[packet->deinterlace_oddness]++;
    85     packet->deinterlace_oddness = (packet->deinterlace_oddness + 1) % 2;
     136  if (packet->current_nibble[packet->deinterlace_oddness] % 2)
     137    packet->current_nibble[packet->deinterlace_oddness]++;
     138  packet->deinterlace_oddness = (packet->deinterlace_oddness + 1) % 2;
    86139}
    87140
    88141static inline unsigned char get_nibble(packet_t *packet)
    89142{
    90     unsigned char nib;
    91     unsigned int *nibblep = packet->current_nibble + packet->deinterlace_oddness;
    92     if (*nibblep / 2 >= packet->control_start) {
    93         dprintf("SPUdec: ERROR: get_nibble past end of packet\n");
    94         return 0;
    95     }
    96     nib = packet->packet[*nibblep / 2];
    97     if (*nibblep % 2)
    98         nib &= 0xf;
    99     else
    100         nib >>= 4;
    101     ++*nibblep;
    102     return nib;
     143  unsigned char nib;
     144  unsigned int *nibblep = packet->current_nibble + packet->deinterlace_oddness;
     145  if (*nibblep / 2 >= packet->control_start) {
     146    mp_msg(MSGT_SPUDEC,MSGL_WARN, "SPUdec: ERROR: get_nibble past end of packet\n");
     147    return 0;
     148  }
     149  nib = packet->packet[*nibblep / 2];
     150  if (*nibblep % 2)
     151    nib &= 0xf;
     152  else
     153    nib >>= 4;
     154  ++*nibblep;
     155  return nib;
    103156}
    104157
    105158static inline int mkalpha(int i)
    106159{
    107     /* In mplayer's alpha planes, 0 is transparent, then 1 is nearly
     160  /* In mplayer's alpha planes, 0 is transparent, then 1 is nearly
    108161     opaque upto 255 which is transparent */
    109     switch (i) {
    110     case 0xf:
    111         return 1;
    112     case 0:
    113         return 0;
    114     default:
    115         return (0xf - i) << 4;
    116     }
     162  switch (i) {
     163  case 0xf:
     164    return 1;
     165  case 0:
     166    return 0;
     167  default:
     168    return (0xf - i) << 4;
     169  }
    117170}
    118171
    … …  
    120173static inline void spudec_cut_image(spudec_handle_t *this)
    121174{
    122     unsigned int fy, ly;
    123     unsigned int first_y, last_y;
    124     unsigned char *image;
    125     unsigned char *aimage;
    126 
    127     if (this->stride == 0 || this->height == 0) {
    128         return;
    129     }
    130 
    131     for (fy = 0; fy < this->image_size && !this->aimage[fy]; fy++);
    132     for (ly = this->stride * this->height-1; ly && !this->aimage[ly]; ly--);
    133     first_y = fy / this->stride;
    134     last_y = ly / this->stride;
    135     //printf("first_y: %d, last_y: %d\n", first_y, last_y);
    136     this->start_row += first_y;
    137 
    138     // Some subtitles trigger this condition
    139     if (last_y + 1 > first_y ) {
    140         this->height = last_y - first_y +1;
     175  unsigned int fy, ly;
     176  unsigned int first_y, last_y;
     177  unsigned char *image;
     178  unsigned char *aimage;
     179
     180  if (this->stride == 0 || this->height == 0) {
     181    return;
     182  }
     183
     184  for (fy = 0; fy < this->image_size && !this->aimage[fy]; fy++);
     185  for (ly = this->stride * this->height-1; ly && !this->aimage[ly]; ly--);
     186  first_y = fy / this->stride;
     187  last_y = ly / this->stride;
     188  //printf("first_y: %d, last_y: %d\n", first_y, last_y);
     189  this->start_row += first_y;
     190
     191  // Some subtitles trigger this condition
     192  if (last_y + 1 > first_y ) {
     193          this->height = last_y - first_y +1;
     194  } else {
     195          this->height = 0;
     196          this->image_size = 0;
     197          return;
     198  }
     199 
     200//  printf("new h %d new start %d (sz %d st %d)---\n\n", this->height, this->start_row, this->image_size, this->stride);
     201
     202  image = malloc(2 * this->stride * this->height);
     203  if(image){
     204    this->image_size = this->stride * this->height;
     205    aimage = image + this->image_size;
     206    memcpy(image, this->image + this->stride * first_y, this->image_size);
     207    memcpy(aimage, this->aimage + this->stride * first_y, this->image_size);
     208    free(this->image);
     209    this->image = image;
     210    this->aimage = aimage;
     211  } else {
     212    mp_msg(MSGT_SPUDEC, MSGL_FATAL, "Fatal: update_spu: malloc requested %d bytes\n", 2 * this->stride * this->height);
     213  }
     214}
     215
     216static void spudec_process_data(spudec_handle_t *this, packet_t *packet)
     217{
     218  unsigned int cmap[4], alpha[4];
     219  unsigned int i, x, y;
     220
     221  this->scaled_frame_width = 0;
     222  this->scaled_frame_height = 0;
     223  this->start_col = packet->start_col;
     224  this->end_col = packet->end_col;
     225  this->start_row = packet->start_row;
     226  this->end_row = packet->end_row;
     227  this->height = packet->height;
     228  this->width = packet->width;
     229  this->stride = packet->stride;
     230  for (i = 0; i < 4; ++i) {
     231    alpha[i] = mkalpha(packet->alpha[i]);
     232    if (alpha[i] == 0)
     233      cmap[i] = 0;
     234    else if (this->custom){
     235      cmap[i] = ((this->cuspal[i] >> 16) & 0xff);
     236      if (cmap[i] + alpha[i] > 255)
     237        cmap[i] = 256 - alpha[i];
     238    }
     239    else {
     240      cmap[i] = ((this->global_palette[packet->palette[i]] >> 16) & 0xff);
     241      if (cmap[i] + alpha[i] > 255)
     242        cmap[i] = 256 - alpha[i];
     243    }
     244  }
     245
     246  if (this->image_size < this->stride * this->height) {
     247    if (this->image != NULL) {
     248      free(this->image);
     249      this->image_size = 0;
     250    }
     251    this->image = malloc(2 * this->stride * this->height);
     252    if (this->image) {
     253      this->image_size = this->stride * this->height;
     254      this->aimage = this->image + this->image_size;
     255    }
     256  }
     257  if (this->image == NULL)
     258    return;
     259
     260  /* Kludge: draw_alpha needs width multiple of 8. */
     261  if (this->width < this->stride)
     262    for (y = 0; y < this->height; ++y) {
     263      memset(this->aimage + y * this->stride + this->width, 0, this->stride - this->width);
     264      /* FIXME: Why is this one needed? */
     265      memset(this->image + y * this->stride + this->width, 0, this->stride - this->width);
     266    }
     267
     268  i = packet->current_nibble[1];
     269  x = 0;
     270  y = 0;
     271  while (packet->current_nibble[0] < i
     272         && packet->current_nibble[1] / 2 < packet->control_start
     273         && y < this->height) {
     274    unsigned int len, color;
     275    unsigned int rle = 0;
     276    rle = get_nibble(packet);
     277    if (rle < 0x04) {
     278      rle = (rle << 4) | get_nibble(packet);
     279      if (rle < 0x10) {
     280        rle = (rle << 4) | get_nibble(packet);
     281        if (rle < 0x040) {
     282          rle = (rle << 4) | get_nibble(packet);
     283          if (rle < 0x0004)
     284            rle |= ((this->width - x) << 2);
     285        }
     286      }
     287    }
     288    color = 3 - (rle & 0x3);
     289    len = rle >> 2;
     290    if (len > this->width - x || len == 0)
     291      len = this->width - x;
     292    /* FIXME have to use palette and alpha map*/
     293    memset(this->image + y * this->stride + x, cmap[color], len);
     294    memset(this->aimage + y * this->stride + x, alpha[color], len);
     295    x += len;
     296    if (x >= this->width) {
     297      next_line(packet);
     298      x = 0;
     299      ++y;
     300    }
     301  }
     302  spudec_cut_image(this);
     303}
     304
     305
     306/*
     307  This function tries to create a usable palette.
     308  It determines how many non-transparent colors are used, and assigns different
     309gray scale values to each color.
     310  I tested it with four streams and even got something readable. Half of the
     311times I got black characters with white around and half the reverse.
     312*/
     313static void compute_palette(spudec_handle_t *this, packet_t *packet)
     314{
     315  int used[16],i,cused,start,step,color;
     316
     317  memset(used, 0, sizeof(used));
     318  for (i=0; i<4; i++)
     319    if (packet->alpha[i]) /* !Transparent? */
     320       used[packet->palette[i]] = 1;
     321  for (cused=0, i=0; i<16; i++)
     322    if (used[i]) cused++;
     323  if (!cused) return;
     324  if (cused == 1) {
     325    start = 0x80;
     326    step = 0;
     327  } else {
     328    start = this->font_start_level;
     329    step = (0xF0-this->font_start_level)/(cused-1);
     330  }
     331  memset(used, 0, sizeof(used));
     332  for (i=0; i<4; i++) {
     333    color = packet->palette[i];
     334    if (packet->alpha[i] && !used[color]) { /* not assigned? */
     335       used[color] = 1;
     336       this->global_palette[color] = start<<16;
     337       start += step;
     338    }
     339  }
     340}
     341
     342static void spudec_process_control(spudec_handle_t *this, unsigned int pts100)
     343{
     344  int a,b; /* Temporary vars */
     345  unsigned int date, type;
     346  unsigned int off;
     347  unsigned int start_off = 0;
     348  unsigned int next_off;
     349  unsigned int start_pts;
     350  unsigned int end_pts;
     351  unsigned int current_nibble[2];
     352  unsigned int control_start;
     353  unsigned int display = 0;
     354  unsigned int start_col = 0;
     355  unsigned int end_col = 0;
     356  unsigned int start_row = 0;
     357  unsigned int end_row = 0;
     358  unsigned int width = 0;
     359  unsigned int height = 0;
     360  unsigned int stride = 0;
     361
     362  control_start = get_be16(this->packet + 2);
     363  next_off = control_start;
     364  while (start_off != next_off) {
     365    start_off = next_off;
     366    date = get_be16(this->packet + start_off) * 1024;
     367    next_off = get_be16(this->packet + start_off + 2);
     368    mp_msg(MSGT_SPUDEC,MSGL_DBG2, "date=%d\n", date);
     369    off = start_off + 4;
     370    for (type = this->packet[off++]; type != 0xff; type = this->packet[off++]) {
     371      mp_msg(MSGT_SPUDEC,MSGL_DBG2, "cmd=%d  ",type);
     372      switch(type) {
     373      case 0x00:
     374        /* Menu ID, 1 byte */
     375        mp_msg(MSGT_SPUDEC,MSGL_DBG2,"Menu ID\n");
     376        /* shouldn't a Menu ID type force display start? */
     377        start_pts = pts100 + date;
     378        end_pts = UINT_MAX;
     379        display = 1;
     380        this->is_forced_sub=~0; // current subtitle is forced
     381        break;
     382      case 0x01:
     383        /* Start display */
     384        mp_msg(MSGT_SPUDEC,MSGL_DBG2,"Start display!\n");
     385        start_pts = pts100 + date;
     386        end_pts = UINT_MAX;
     387        display = 1;
     388        this->is_forced_sub=0;
     389        break;
     390      case 0x02:
     391        /* Stop display */
     392        mp_msg(MSGT_SPUDEC,MSGL_DBG2,"Stop display!\n");
     393        end_pts = pts100 + date;
     394        break;
     395      case 0x03:
     396        /* Palette */
     397        this->palette[0] = this->packet[off] >> 4;
     398        this->palette[1] = this->packet[off] & 0xf;
     399        this->palette[2] = this->packet[off + 1] >> 4;
     400        this->palette[3] = this->packet[off + 1] & 0xf;
     401        mp_msg(MSGT_SPUDEC,MSGL_DBG2,"Palette %d, %d, %d, %d\n",
     402               this->palette[0], this->palette[1], this->palette[2], this->palette[3]);
     403        off+=2;
     404        break;
     405      case 0x04:
     406        /* Alpha */
     407        this->alpha[0] = this->packet[off] >> 4;
     408        this->alpha[1] = this->packet[off] & 0xf;
     409        this->alpha[2] = this->packet[off + 1] >> 4;
     410        this->alpha[3] = this->packet[off + 1] & 0xf;
     411        mp_msg(MSGT_SPUDEC,MSGL_DBG2,"Alpha %d, %d, %d, %d\n",
     412               this->alpha[0], this->alpha[1], this->alpha[2], this->alpha[3]);
     413        off+=2;
     414        break;
     415      case 0x05:
     416        /* Co-ords */
     417        a = get_be24(this->packet + off);
     418        b = get_be24(this->packet + off + 3);
     419        start_col = a >> 12;
     420        end_col = a & 0xfff;
     421        width = (end_col < start_col) ? 0 : end_col - start_col + 1;
     422        stride = (width + 7) & ~7; /* Kludge: draw_alpha needs width multiple of 8 */
     423        start_row = b >> 12;
     424        end_row = b & 0xfff;
     425        height = (end_row < start_row) ? 0 : end_row - start_row /* + 1 */;
     426        mp_msg(MSGT_SPUDEC,MSGL_DBG2,"Coords  col: %d - %d  row: %d - %d  (%dx%d)\n",
     427               start_col, end_col, start_row, end_row,
     428               width, height);
     429        off+=6;
     430        break;
     431      case 0x06:
     432        /* Graphic lines */
     433        current_nibble[0] = 2 * get_be16(this->packet + off);
     434        current_nibble[1] = 2 * get_be16(this->packet + off + 2);
     435        mp_msg(MSGT_SPUDEC,MSGL_DBG2,"Graphic offset 1: %d  offset 2: %d\n",
     436               current_nibble[0] / 2, current_nibble[1] / 2);
     437        off+=4;
     438        break;
     439      case 0xff:
     440        /* All done, bye-bye */
     441        mp_msg(MSGT_SPUDEC,MSGL_DBG2,"Done!\n");
     442        return;
     443//      break;
     444      default:
     445        mp_msg(MSGT_SPUDEC,MSGL_WARN,"spudec: Error determining control type 0x%02x.  Skipping %d bytes.\n",
     446               type, next_off - off);
     447        goto next_control;
     448      }
     449    }
     450  next_control:
     451    if (display) {
     452      packet_t *packet = calloc(1, sizeof(packet_t));
     453      int i;
     454      packet->start_pts = start_pts;
     455      if (end_pts == UINT_MAX && start_off != next_off) {
     456        start_pts = pts100 + get_be16(this->packet + next_off) * 1024;
     457        packet->end_pts = start_pts - 1;
     458      } else packet->end_pts = end_pts;
     459      packet->current_nibble[0] = current_nibble[0];
     460      packet->current_nibble[1] = current_nibble[1];
     461      packet->start_row = start_row;
     462      packet->end_row = end_row;
     463      packet->start_col = start_col;
     464      packet->end_col = end_col;
     465      packet->width = width;
     466      packet->height = height;
     467      packet->stride = stride;
     468      packet->control_start = control_start;
     469      for (i=0; i<4; i++) {
     470        packet->alpha[i] = this->alpha[i];
     471        packet->palette[i] = this->palette[i];
     472      }
     473      packet->packet = malloc(this->packet_size);
     474      memcpy(packet->packet, this->packet, this->packet_size);
     475      spudec_queue_packet(this, packet);
     476    }
     477  }
     478}
     479
     480static void spudec_decode(spudec_handle_t *this, unsigned int pts100)
     481{
     482#if 0
     483  if(this->hw_spu) {
     484    static vo_mpegpes_t packet = { NULL, 0, 0x20, 0 };
     485    static vo_mpegpes_t *pkg=&packet;
     486    packet.data = this->packet;
     487    packet.size = this->packet_size;
     488    packet.timestamp = pts100;
     489    this->hw_spu->draw_frame((uint8_t**)&pkg);
     490  } else
     491#endif
     492    spudec_process_control(this, pts100);
     493}
     494
     495int spudec_changed(void * this)
     496{
     497    spudec_handle_t * spu = (spudec_handle_t*)this;
     498    return (spu->spu_changed || spu->now_pts > spu->end_pts);
     499}
     500
     501void spudec_assemble(void *this, unsigned char *packet, unsigned int len, unsigned int pts100)
     502{
     503  spudec_handle_t *spu = (spudec_handle_t*)this;
     504//  spudec_heartbeat(this, pts100);
     505  if (len < 2) {
     506      mp_msg(MSGT_SPUDEC,MSGL_WARN,"SPUasm: packet too short\n");
     507      return;
     508  }
     509#if 0
     510  if ((spu->packet_pts + 10000) < pts100) {
     511    // [cb] too long since last fragment: force new packet
     512    spu->packet_offset = 0;
     513  }
     514#endif
     515  spu->packet_pts = pts100;
     516  if (spu->packet_offset == 0) {
     517    unsigned int len2 = get_be16(packet);
     518    // Start new fragment
     519    if (spu->packet_reserve < len2) {
     520      if (spu->packet != NULL)
     521        free(spu->packet);
     522      spu->packet = malloc(len2);
     523      spu->packet_reserve = spu->packet != NULL ? len2 : 0;
     524    }
     525    if (spu->packet != NULL) {
     526      spu->packet_size = len2;
     527      if (len > len2) {
     528        mp_msg(MSGT_SPUDEC,MSGL_WARN,"SPUasm: invalid frag len / len2: %d / %d \n", len, len2);
     529        return;
     530      }
     531      memcpy(spu->packet, packet, len);
     532      spu->packet_offset = len;
     533      spu->packet_pts = pts100;
     534    }
     535  } else {
     536    // Continue current fragment
     537    if (spu->packet_size < spu->packet_offset + len){
     538      mp_msg(MSGT_SPUDEC,MSGL_WARN,"SPUasm: invalid fragment\n");
     539      spu->packet_size = spu->packet_offset = 0;
     540      return;
    141541    } else {
    142         this->height = 0;
    143         this->image_size = 0;
    144         return;
    145     }
    146 
    147     //  printf("new h %d new start %d (sz %d st %d)---\n\n", this->height, this->start_row, this->image_size, this->stride);
    148 
    149     image = malloc(2 * this->stride * this->height);
    150     if(image){
    151         this->image_size = this->stride * this->height;
    152         aimage = image + this->image_size;
    153         memcpy(image, this->image + this->stride * first_y, this->image_size);
    154         memcpy(aimage, this->aimage + this->stride * first_y, this->image_size);
    155         free(this->image);
    156         this->image = image;
    157         this->aimage = aimage;
    158     } else {
    159         dprintf("Fatal: update_spu: malloc requested %d bytes\n", 2 * this->stride * this->height);
    160     }
    161 }
    162 
    163 static void spudec_process_data(spudec_handle_t *this, packet_t *packet)
    164 {
    165     unsigned int cmap[4], alpha[4];
    166     unsigned int i, x, y;
    167 
    168     this->scaled_frame_width = 0;
    169     this->scaled_frame_height = 0;
    170     this->start_col = packet->start_col;
    171     this->end_col = packet->end_col;
    172     this->start_row = packet->start_row;
    173     this->end_row = packet->end_row;
    174     this->height = packet->height;
    175     this->width = packet->width;
    176     this->stride = packet->stride;
    177     for (i = 0; i < 4; ++i) {
    178         alpha[i] = mkalpha(packet->alpha[i]);
    179         if (alpha[i] == 0)
    180             cmap[i] = 0;
    181         else if (this->custom){
    182             cmap[i] = ((this->cuspal[i] >> 16) & 0xff);
    183             if (cmap[i] + alpha[i] > 255)
    184                 cmap[i] = 256 - alpha[i];
    185         }
    186         else {
    187             cmap[i] = ((this->global_palette[packet->palette[i]] >> 16) & 0xff);
    188             if (cmap[i] + alpha[i] > 255)
    189                 cmap[i] = 256 - alpha[i];
    190         }
    191     }
    192 
    193     if (this->image_size < this->stride * this->height) {
    194         if (this->image != NULL) {
    195             free(this->image);
    196             this->image_size = 0;
    197         }
    198         this->image = malloc(2 * this->stride * this->height);
    199         if (this->image) {
    200             this->image_size = this->stride * this->height;
    201             this->aimage = this->image + this->image_size;
    202         }
    203     }
    204     if (this->image == NULL)
    205         return;
    206 
    207     /* Kludge: draw_alpha needs width multiple of 8. */
    208     if (this->width < this->stride)
    209         for (y = 0; y < this->height; ++y) {
    210             memset(this->aimage + y * this->stride + this->width, 0, this->stride - this->width);
    211             /* FIXME: Why is this one needed? */
    212             memset(this->image + y * this->stride + this->width, 0, this->stride - this->width);
    213         }
    214 
    215     i = packet->current_nibble[1];
    216     x = 0;
    217     y = 0;
    218     while (packet->current_nibble[0] < i
    219            && packet->current_nibble[1] / 2 < packet->control_start
    220            && y < this->height) {
    221         unsigned int len, color;
    222         unsigned int rle = 0;
    223         rle = get_nibble(packet);
    224         if (rle < 0x04) {
    225             rle = (rle << 4) | get_nibble(packet);
    226             if (rle < 0x10) {
    227                 rle = (rle << 4) | get_nibble(packet);
    228                 if (rle < 0x040) {
    229                     rle = (rle << 4) | get_nibble(packet);
    230                     if (rle < 0x0004)
    231                         rle |= ((this->width - x) << 2);
    232                 }
    233             }
    234         }
    235         color = 3 - (rle & 0x3);
    236         len = rle >> 2;
    237         if (len > this->width - x || len == 0)
    238             len = this->width - x;
    239         /* FIXME have to use palette and alpha map*/
    240         memset(this->image + y * this->stride + x, cmap[color], len);
    241         memset(this->aimage + y * this->stride + x, alpha[color], len);
    242         x += len;
    243         if (x >= this->width) {
    244             next_line(packet);
    245             x = 0;
    246             ++y;
    247         }
    248     }
    249     spudec_cut_image(this);
    250 }
    251 
    252 
    253 /*
    254  This function tries to create a usable palette.
    255  It determines how many non-transparent colors are used, and assigns different
    256  gray scale values to each color.
    257  I tested it with four streams and even got something readable. Half of the
    258  times I got black characters with white around and half the reverse.
    259  */
    260 static void compute_palette(spudec_handle_t *this, packet_t *packet)
    261 {
    262     int used[16],i,cused,start,step,color;
    263 
    264     memset(used, 0, sizeof(used));
    265     for (i=0; i<4; i++)
    266         if (packet->alpha[i]) /* !Transparent? */
    267             used[packet->palette[i]] = 1;
    268     for (cused=0, i=0; i<16; i++)
    269         if (used[i]) cused++;
    270     if (!cused) return;
    271     if (cused == 1) {
    272         start = 0x80;
    273         step = 0;
    274     } else {
    275         start = this->font_start_level;
    276         step = (0xF0-this->font_start_level)/(cused-1);
    277     }
    278     memset(used, 0, sizeof(used));
    279     for (i=0; i<4; i++) {
    280         color = packet->palette[i];
    281         if (packet->alpha[i] && !used[color]) { /* not assigned? */
    282             used[color] = 1;
    283             this->global_palette[color] = start<<16;
    284             start += step;
    285         }
    286     }
    287 }
    288 
    289 static void spudec_process_control(spudec_handle_t *this, unsigned int pts100)
    290 {
    291     int a,b; /* Temporary vars */
    292     unsigned int date, type;
    293     unsigned int off;
    294     unsigned int start_off = 0;
    295     unsigned int next_off;
    296     unsigned int start_pts;
    297     unsigned int end_pts;
    298     unsigned int current_nibble[2];
    299     unsigned int control_start;
    300     unsigned int display = 0;
    301     unsigned int start_col = 0;
    302     unsigned int end_col = 0;
    303     unsigned int start_row = 0;
    304     unsigned int end_row = 0;
    305     unsigned int width = 0;
    306     unsigned int height = 0;
    307     unsigned int stride = 0;
    308 
    309     control_start = get_be16(this->packet + 2);
    310     next_off = control_start;
    311     while (start_off != next_off) {
    312         start_off = next_off;
    313         date = get_be16(this->packet + start_off) * 1024;
    314         next_off = get_be16(this->packet + start_off + 2);
    315         dprintf("date=%d\n", date);
    316         off = start_off + 4;
    317         for (type = this->packet[off++]; type != 0xff; type = this->packet[off++]) {
    318             dprintf("cmd=%d  ",type);
    319             switch(type) {
    320             case 0x00:
    321                 /* Menu ID, 1 byte */
    322                 dprintf("Menu ID\n");
    323                 /* shouldn't a Menu ID type force display start? */
    324                 start_pts = pts100 + date;
    325                 end_pts = UINT_MAX;
    326                 display = 1;
    327                 this->is_forced_sub=~0; // current subtitle is forced
    328                 break;
    329             case 0x01:
    330                 /* Start display */
    331                 dprintf("Start display!\n");
    332                 start_pts = pts100 + date;
    333                 end_pts = UINT_MAX;
    334                 display = 1;
    335                 this->is_forced_sub=0;
    336                 break;
    337             case 0x02:
    338                 /* Stop display */
    339                 dprintf("Stop display!\n");
    340                 end_pts = pts100 + date;
    341                 break;
    342             case 0x03:
    343                 /* Palette */
    344                 this->palette[0] = this->packet[off] >> 4;
    345                 this->palette[1] = this->packet[off] & 0xf;
    346                 this->palette[2] = this->packet[off + 1] >> 4;
    347                 this->palette[3] = this->packet[off + 1] & 0xf;
    348                 dprintf("Palette %d, %d, %d, %d\n",
    349                         this->palette[0], this->palette[1], this->palette[2], this->palette[3]);
    350                 off+=2;
    351                 break;
    352             case 0x04:
    353                 /* Alpha */
    354                 this->alpha[0] = this->packet[off] >> 4;
    355                 this->alpha[1] = this->packet[off] & 0xf;
    356                 this->alpha[2] = this->packet[off + 1] >> 4;
    357                 this->alpha[3] = this->packet[off + 1] & 0xf;
    358                 dprintf("Alpha %d, %d, %d, %d\n",
    359                         this->alpha[0], this->alpha[1], this->alpha[2], this->alpha[3]);
    360                 off+=2;
    361                 break;
    362             case 0x05:
    363                 /* Co-ords */
    364                 a = get_be24(this->packet + off);
    365                 b = get_be24(this->packet + off + 3);
    366                 start_col = a >> 12;
    367                 end_col = a & 0xfff;
    368                 width = (end_col < start_col) ? 0 : end_col - start_col + 1;
    369                 stride = (width + 7) & ~7; /* Kludge: draw_alpha needs width multiple of 8 */
    370                 start_row = b >> 12;
    371                 end_row = b & 0xfff;
    372                 height = (end_row < start_row) ? 0 : end_row - start_row /* + 1 */;
    373                 dprintf("Coords  col: %d - %d  row: %d - %d  (%dx%d)\n",
    374                         start_col, end_col, start_row, end_row,
    375                         width, height);
    376                 off+=6;
    377                 break;
    378             case 0x06:
    379                 /* Graphic lines */
    380                 current_nibble[0] = 2 * get_be16(this->packet + off);
    381                 current_nibble[1] = 2 * get_be16(this->packet + off + 2);
    382                 dprintf("Graphic offset 1: %d  offset 2: %d\n",
    383                         current_nibble[0] / 2, current_nibble[1] / 2);
    384                 off+=4;
    385                 break;
    386             case 0xff:
    387                 /* All done, bye-bye */
    388                 dprintf("Done!\n");
    389                 return;
    390                 //      break;
    391             default:
    392                 dprintf("spudec: Error determining control type 0x%02x.  Skipping %d bytes.\n",
    393                         type, next_off - off);
    394                 goto next_control;
    395             }
    396         }
    397     next_control:
    398         if (display) {
    399             packet_t *packet = calloc(1, sizeof(packet_t));
    400             int i;
    401             packet->start_pts = start_pts;
    402             if (end_pts == UINT_MAX && start_off != next_off) {
    403                 start_pts = pts100 + get_be16(this->packet + next_off) * 1024;
    404                 packet->end_pts = start_pts - 1;
    405             } else packet->end_pts = end_pts;
    406             packet->current_nibble[0] = current_nibble[0];
    407             packet->current_nibble[1] = current_nibble[1];
    408             packet->start_row = start_row;
    409             packet->end_row = end_row;
    410             packet->start_col = start_col;
    411             packet->end_col = end_col;
    412             packet->width = width;
    413             packet->height = height;
    414             packet->stride = stride;
    415             packet->control_start = control_start;
    416             for (i=0; i<4; i++) {
    417                 packet->alpha[i] = this->alpha[i];
    418                 packet->palette[i] = this->palette[i];
    419             }
    420             packet->packet = malloc(this->packet_size);
    421             memcpy(packet->packet, this->packet, this->packet_size);
    422             spudec_queue_packet(this, packet);
    423         }
    424     }
    425 }
    426 
    427 static void spudec_decode(spudec_handle_t *this, unsigned int pts100)
    428 {
    429 #if 0
    430     if(this->hw_spu) {
    431         static vo_mpegpes_t packet = { NULL, 0, 0x20, 0 };
    432         static vo_mpegpes_t *pkg=&packet;
    433         packet.data = this->packet;
    434         packet.size = this->packet_size;
    435         packet.timestamp = pts100;
    436         this->hw_spu->draw_frame((uint8_t**)&pkg);
    437     } else
     542      memcpy(spu->packet + spu->packet_offset, packet, len);
     543      spu->packet_offset += len;
     544    }
     545  }
     546#if 1
     547  // check if we have a complete packet (unfortunatelly packet_size is bad
     548  // for some disks)
     549  // [cb] packet_size is padded to be even -> may be one byte too long
     550  if ((spu->packet_offset == spu->packet_size) ||
     551      ((spu->packet_offset + 1) == spu->packet_size)){
     552    unsigned int x=0,y;
     553    while(x+4<=spu->packet_offset){
     554      y=get_be16(spu->packet+x+2); // next control pointer
     555      mp_msg(MSGT_SPUDEC,MSGL_DBG2,"SPUtest: x=%d y=%d off=%d size=%d\n",x,y,spu->packet_offset,spu->packet_size);
     556      if(x>=4 && x==y){         // if it points to self - we're done!
     557        // we got it!
     558        mp_msg(MSGT_SPUDEC,MSGL_DBG2,"SPUgot: off=%d  size=%d \n",spu->packet_offset,spu->packet_size);
     559        spudec_decode(spu, pts100);
     560        spu->packet_offset = 0;
     561        break;
     562      }
     563      if(y<=x || y>=spu->packet_size){ // invalid?
     564        mp_msg(MSGT_SPUDEC,MSGL_WARN,"SPUtest: broken packet!!!!! y=%d < x=%d\n",y,x);
     565        spu->packet_size = spu->packet_offset = 0;
     566        break;
     567      }
     568      x=y;
     569    }
     570    // [cb] packet is done; start new packet
     571    spu->packet_offset = 0;
     572  }
     573#else
     574  if (spu->packet_offset == spu->packet_size) {
     575    spudec_decode(spu, pts100);
     576    spu->packet_offset = 0;
     577  }
    438578#endif
    439         spudec_process_control(this, pts100);
    440 }
    441 
    442 int spudec_changed(void * this)
    443 {
    444     spudec_handle_t * spu = (spudec_handle_t*)this;
    445 //    printf("cht: %i, now pts %i, end pts %i\n",spu->spu_changed, spu->now_pts, spu->end_pts);
    446     if (spu->spu_changed || (spu->now_pts > spu->end_pts))
    447         return 1;
    448     else
    449         return 0;
    450 }
    451 
    452 void spudec_assemble(void *this, unsigned char *packet, unsigned int len, unsigned int pts100)
    453 {
    454     spudec_handle_t *spu = (spudec_handle_t*)this;
    455     //  spudec_heartbeat(this, pts100);
    456     if (len < 2) {
    457         dprintf("SPUasm: packet too short\n");
    458         return;
    459     }
    460     if ((spu->packet_pts + 10000) < pts100) {
    461         // [cb] too long since last fragment: force new packet
    462         spu->packet_offset = 0;
    463     }
    464     spu->packet_pts = pts100;
    465     if (spu->packet_offset == 0) {
    466         unsigned int len2 = get_be16(packet);
    467         // Start new fragment
    468         if (spu->packet_reserve < len2) {
    469             if (spu->packet != NULL)
    470                 free(spu->packet);
    471             spu->packet = malloc(len2);
    472             spu->packet_reserve = spu->packet != NULL ? len2 : 0;
    473         }
    474         if (spu->packet != NULL) {
    475             spu->packet_size = len2;
    476             if (len > len2) {
    477                 dprintf("SPUasm: invalid frag len / len2: %d / %d \n", len, len2);
    478                 return;
    479             }
    480             memcpy(spu->packet, packet, len);
    481             spu->packet_offset = len;
    482             spu->packet_pts = pts100;
    483         }
    484     } else {
    485         // Continue current fragment
    486         if (spu->packet_size < spu->packet_offset + len){
    487             dprintf("SPUasm: invalid fragment\n");
    488             spu->packet_size = spu->packet_offset = 0;
    489             return;
    490         } else {
    491             memcpy(spu->packet + spu->packet_offset, packet, len);
    492             spu->packet_offset += len;
    493         }
    494     }
    495 #if 1
    496     // check if we have a complete packet (unfortunatelly packet_size is bad
    497     // for some disks)
    498     // [cb] packet_size is padded to be even -> may be one byte too long
    499     if ((spu->packet_offset == spu->packet_size) ||
    500         ((spu->packet_offset + 1) == spu->packet_size)){
    501         unsigned int x=0,y;
    502         while(x+4<=spu->packet_offset){
    503             y=get_be16(spu->packet+x+2); // next control pointer
    504             dprintf("SPUtest: x=%d y=%d off=%d size=%d\n",x,y,spu->packet_offset,spu->packet_size);
    505             if(x>=4 && x==y){           // if it points to self - we're done!
    506                 // we got it!
    507                 dprintf("SPUgot: off=%d  size=%d \n",spu->packet_offset,spu->packet_size);
    508                 spudec_decode(spu, pts100);
    509                 spu->packet_offset = 0;
    510                 break;
    511             }
    512             if(y<=x || y>=spu->packet_size){ // invalid?
    513                 dprintf("SPUtest: broken packet!!!!! y=%d < x=%d\n",y,x);
    514                 spu->packet_size = spu->packet_offset = 0;
    515                 break;
    516             }
    517             x=y;
    518         }
    519         // [cb] packet is done; start new packet
    520         spu->packet_offset = 0;
    521     }
    522 #else
    523     if (spu->packet_offset == spu->packet_size) {
    524         spudec_decode(spu, pts100);
    525         spu->packet_offset = 0;
    526     }
    527 #endif
    528579}
    529580
    530581void spudec_reset(void *this)   // called after seek
    531582{
    532     spudec_handle_t *spu = (spudec_handle_t*)this;
    533     while (spu->queue_head)
    534         spudec_free_packet(spudec_dequeue_packet(spu));
    535     spu->now_pts = 0;
    536     spu->end_pts = 0;
    537     spu->packet_size = spu->packet_offset = 0;
     583  spudec_handle_t *spu = (spudec_handle_t*)this;
     584  while (spu->queue_head)
     585    spudec_free_packet(spudec_dequeue_packet(spu));
     586  spu->now_pts = 0;
     587  spu->end_pts = 0;
     588  spu->packet_size = spu->packet_offset = 0;
    538589}
    539590
    540591void spudec_heartbeat(void *this, unsigned int pts100)
    541 {
    542     spudec_handle_t *spu = (spudec_handle_t*) this;
    543     spu->now_pts = pts100;
    544 
    545     while (spu->queue_head != NULL && pts100 >= spu->queue_head->start_pts) {
    546         packet_t *packet = spudec_dequeue_packet(spu);
    547         spu->start_pts = packet->start_pts;
    548         spu->end_pts = packet->end_pts;
    549         if (spu->auto_palette)
    550             compute_palette(spu, packet);
    551         spudec_process_data(spu, packet);
    552         spudec_free_packet(packet);
    553         spu->spu_changed = 1;
    554     }
     592{ 
     593  spudec_handle_t *spu = (spudec_handle_t*) this;
     594  spu->now_pts = pts100;
     595
     596  while (spu->queue_head != NULL && pts100 >= spu->queue_head->start_pts) {
     597    packet_t *packet = spudec_dequeue_packet(spu);
     598    spu->start_pts = packet->start_pts;
     599    spu->end_pts = packet->end_pts;
     600    if (spu->auto_palette)
     601      compute_palette(spu, packet);
     602    spudec_process_data(spu, packet);
     603    spudec_free_packet(packet);
     604    spu->spu_changed = 1;
     605  }
    555606}
    556607
    … …  
    558609    spudec_handle_t *spu = (spudec_handle_t *)this;
    559610    int ret=(spu->start_pts <= spu->now_pts &&
    560              spu->now_pts < spu->end_pts &&
    561              spu->height > 0);
    562     //    printf("spu visible: %d  \n",ret);
     611             spu->now_pts < spu->end_pts &&
     612             spu->height > 0);
     613//    printf("spu visible: %d  \n",ret);
    563614    return ret;
    564615}
    … …  
    566617void spudec_set_forced_subs_only(void * const this, const unsigned int flag)
    567618{
    568     if(this){
    569         ((spudec_handle_t *)this)->forced_subs_only=flag;
    570         dprintf("SPU: Display only forced subs now %s\n", flag ? "enabled": "disabled");
    571     }
     619  if(this){
     620      ((spudec_handle_t *)this)->forced_subs_only=flag;
     621      mp_msg(MSGT_SPUDEC,MSGL_DBG2,"SPU: Display only forced subs now %s\n", flag ? "enabled": "disabled");
     622  }
    572623}
    573624
    … …  
    575626{
    576627    spudec_handle_t *spu = (spudec_handle_t *)this;
    577     if (spu->start_pts <= spu->now_pts && spu->now_pts < spu->end_pts && spu->image)
     628    dprintf("s_pts: %f, n_pts: %f, e_pts: %f. img: %x\n",
     629           spu->start_pts, spu->now_pts, spu->end_pts, spu->image);
     630    if (spu->start_pts <= spu->now_pts && spu->now_pts <= spu->end_pts && spu->image)
    578631    {
    579         draw_alpha(spu->start_col, spu->start_row, spu->width, spu->height,
    580                    spu->image, spu->aimage, spu->stride);
    581         spu->spu_changed = 0;
     632        draw_alpha(spu->start_col, spu->start_row, spu->width, spu->height,
     633                   spu->image, spu->aimage, spu->stride);
     634        spu->spu_changed = 0;
    582635    }
    583636}
    … …  
    586639void spudec_calc_bbox(void *me, unsigned int dxs, unsigned int dys, unsigned int* bbox)
    587640{
    588     spudec_handle_t *spu;
    589     spu = (spudec_handle_t *)me;
    590     if (spu->orig_frame_width == 0 || spu->orig_frame_height == 0
    591         || (spu->orig_frame_width == dxs && spu->orig_frame_height == dys)) {
    592         bbox[0] = spu->start_col;
    593         bbox[1] = spu->start_col + spu->width;
    594         bbox[2] = spu->start_row;
    595         bbox[3] = spu->start_row + spu->height;
    596     }
    597     else if (spu->scaled_frame_width != dxs || spu->scaled_frame_height != dys) {
    598         unsigned int scalex = 0x100 * dxs / spu->orig_frame_width;
    599         unsigned int scaley = 0x100 * dys / spu->orig_frame_height;
    600         bbox[0] = spu->start_col * scalex / 0x100;
    601         bbox[1] = spu->start_col * scalex / 0x100 + spu->width * scalex / 0x100;
     641  spudec_handle_t *spu;
     642  spu = (spudec_handle_t *)me;
     643  if (spu->orig_frame_width == 0 || spu->orig_frame_height == 0
     644  || (spu->orig_frame_width == dxs && spu->orig_frame_height == dys)) {
     645    bbox[0] = spu->start_col;
     646    bbox[1] = spu->start_col + spu->width;
     647    bbox[2] = spu->start_row;
     648    bbox[3] = spu->start_row + spu->height;
     649  }
     650  else if (spu->scaled_frame_width != dxs || spu->scaled_frame_height != dys) {
     651    unsigned int scalex = 0x100 * dxs / spu->orig_frame_width;
     652    unsigned int scaley = 0x100 * dys / spu->orig_frame_height;
     653    bbox[0] = spu->start_col * scalex / 0x100;
     654    bbox[1] = spu->start_col * scalex / 0x100 + spu->width * scalex / 0x100;
     655    switch (spu_alignment) {
     656    case 0:
     657      bbox[3] = dys*sub_pos/100 + spu->height * scaley / 0x100;
     658      if (bbox[3] > dys) bbox[3] = dys;
     659      bbox[2] = bbox[3] - spu->height * scaley / 0x100;
     660      break;
     661    case 1:
     662      if (sub_pos < 50) {
     663        bbox[2] = dys*sub_pos/100 - spu->height * scaley / 0x200;
     664        if (bbox[2] < 0) bbox[2] = 0;
     665        bbox[3] = bbox[2] + spu->height;
     666      } else {
     667        bbox[3] = dys*sub_pos/100 + spu->height * scaley / 0x200;
     668        if (bbox[3] > dys) bbox[3] = dys;
     669        bbox[2] = bbox[3] - spu->height * scaley / 0x100;
     670      }
     671      break;
     672    case 2:
     673      bbox[2] = dys*sub_pos/100 - spu->height * scaley / 0x100;
     674      if (bbox[2] < 0) bbox[2] = 0;
     675      bbox[3] = bbox[2] + spu->height;
     676      break;
     677    default: /* -1 */
     678      bbox[2] = spu->start_row * scaley / 0x100;
     679      bbox[3] = spu->start_row * scaley / 0x100 + spu->height * scaley / 0x100;
     680      break;
     681    }
     682  }
     683}
     684/* transform mplayer's alpha value into an opacity value that is linear */
     685static inline int canon_alpha(int alpha)
     686{
     687  return alpha ? 256 - alpha : 0;
     688}
     689
     690typedef struct {
     691  unsigned position;
     692  unsigned left_up;
     693  unsigned right_down;
     694}scale_pixel;
     695
     696
     697static void scale_table(unsigned int start_src, unsigned int start_tar, unsigned int end_src, unsigned int end_tar, scale_pixel * table)
     698{
     699  unsigned int t;
     700  unsigned int delta_src = end_src - start_src;
     701  unsigned int delta_tar = end_tar - start_tar;
     702  int src = 0;
     703  int src_step;
     704  if (delta_src == 0 || delta_tar == 0) {
     705    return;
     706  }
     707  src_step = (delta_src << 16) / delta_tar >>1;
     708  for (t = 0; t<=delta_tar; src += (src_step << 1), t++){
     709    table[t].position= MIN(src >> 16, end_src - 1);
     710    table[t].right_down = src & 0xffff;
     711    table[t].left_up = 0x10000 - table[t].right_down;
     712  }
     713}
     714
     715/* bilinear scale, similar to vobsub's code */
     716static void scale_image(int x, int y, scale_pixel* table_x, scale_pixel* table_y, spudec_handle_t * spu)
     717{
     718  int alpha[4];
     719  int color[4];
     720  unsigned int scale[4];
     721  int base = table_y[y].position * spu->stride + table_x[x].position;
     722  int scaled = y * spu->scaled_stride + x;
     723  alpha[0] = canon_alpha(spu->aimage[base]);
     724  alpha[1] = canon_alpha(spu->aimage[base + 1]);
     725  alpha[2] = canon_alpha(spu->aimage[base + spu->stride]);
     726  alpha[3] = canon_alpha(spu->aimage[base + spu->stride + 1]);
     727  color[0] = spu->image[base];
     728  color[1] = spu->image[base + 1];
     729  color[2] = spu->image[base + spu->stride];
     730  color[3] = spu->image[base + spu->stride + 1];
     731  scale[0] = (table_x[x].left_up * table_y[y].left_up >> 16) * alpha[0];
     732  scale[1] = (table_x[x].right_down * table_y[y].left_up >>16) * alpha[1];
     733  scale[2] = (table_x[x].left_up * table_y[y].right_down >> 16) * alpha[2];
     734  scale[3] = (table_x[x].right_down * table_y[y].right_down >> 16) * alpha[3];
     735  spu->scaled_image[scaled] = (color[0] * scale[0] + color[1] * scale[1] + color[2] * scale[2] + color[3] * scale[3])>>24;
     736  spu->scaled_aimage[scaled] = (scale[0] + scale[1] + scale[2] + scale[3]) >> 16;
     737  if (spu->scaled_aimage[scaled]){
     738    spu->scaled_aimage[scaled] = 256 - spu->scaled_aimage[scaled];
     739    if(spu->scaled_aimage[scaled] + spu->scaled_image[scaled] > 255)
     740      spu->scaled_image[scaled] = 256 - spu->scaled_aimage[scaled];
     741  }
     742}
     743
     744void sws_spu_image(unsigned char *d1, unsigned char *d2, int dw, int dh, int ds,
     745        unsigned char *s1, unsigned char *s2, int sw, int sh, int ss)
     746{
     747        struct SwsContext *ctx;
     748        static SwsFilter filter;
     749        static int firsttime = 1;
     750        static float oldvar;
     751        int i;
     752
     753        if (!firsttime && oldvar != spu_gaussvar) sws_freeVec(filter.lumH);
     754        if (firsttime) {
     755                filter.lumH = filter.lumV =
     756                        filter.chrH = filter.chrV = sws_getGaussianVec(spu_gaussvar, 3.0);
     757                sws_normalizeVec(filter.lumH, 1.0);
     758                firsttime = 0;
     759                oldvar = spu_gaussvar;
     760        }
     761       
     762        ctx=sws_getContext(sw, sh, PIX_FMT_GRAY8, dw, dh, PIX_FMT_GRAY8, SWS_GAUSS, &filter, NULL, NULL);
     763        sws_scale(ctx,&s1,&ss,0,sh,&d1,&ds);
     764        for (i=ss*sh-1; i>=0; i--) if (!s2[i]) s2[i] = 255; //else s2[i] = 1;
     765        sws_scale(ctx,&s2,&ss,0,sh,&d2,&ds);
     766        for (i=ds*dh-1; i>=0; i--) if (d2[i]==0) d2[i] = 1; else if (d2[i]==255) d2[i] = 0;
     767        sws_freeContext(ctx);
     768}
     769
     770void spudec_draw_scaled(void *me, unsigned int dxs, unsigned int dys, void (*draw_alpha)(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride))
     771{
     772  spudec_handle_t *spu = (spudec_handle_t *)me;
     773  scale_pixel *table_x;
     774  scale_pixel *table_y;
     775
     776  if (spu->start_pts <= spu->now_pts && spu->now_pts < spu->end_pts) {
     777
     778    // check if only forced subtitles are requested
     779    if( (spu->forced_subs_only) && !(spu->is_forced_sub) ){
     780        return;
     781    }
     782
     783    if (!(spu_aamode&16) && (spu->orig_frame_width == 0 || spu->orig_frame_height == 0
     784        || (spu->orig_frame_width == dxs && spu->orig_frame_height == dys))) {
     785      if (spu->image)
     786      {
     787        draw_alpha(spu->start_col, spu->start_row, spu->width, spu->height,
     788                   spu->image, spu->aimage, spu->stride);
     789        spu->spu_changed = 0;
     790      }
     791    }
     792    else {
     793      if (spu->scaled_frame_width != dxs || spu->scaled_frame_height != dys) {  /* Resizing is needed */
     794        /* scaled_x = scalex * x / 0x100
     795           scaled_y = scaley * y / 0x100
     796           order of operations is important because of rounding. */
     797        unsigned int scalex = 0x100 * dxs / spu->orig_frame_width;
     798        unsigned int scaley = 0x100 * dys / spu->orig_frame_height;
     799        spu->scaled_start_col = spu->start_col * scalex / 0x100;
     800        spu->scaled_start_row = spu->start_row * scaley / 0x100;
     801        spu->scaled_width = spu->width * scalex / 0x100;
     802        spu->scaled_height = spu->height * scaley / 0x100;
     803        /* Kludge: draw_alpha needs width multiple of 8 */
     804        spu->scaled_stride = (spu->scaled_width + 7) & ~7;
     805        if (spu->scaled_image_size < spu->scaled_stride * spu->scaled_height) {
     806          if (spu->scaled_image) {
     807            free(spu->scaled_image);
     808            spu->scaled_image_size = 0;
     809          }
     810          spu->scaled_image = malloc(2 * spu->scaled_stride * spu->scaled_height);
     811          if (spu->scaled_image) {
     812            spu->scaled_image_size = spu->scaled_stride * spu->scaled_height;
     813            spu->scaled_aimage = spu->scaled_image + spu->scaled_image_size;
     814          }
     815        }
     816        if (spu->scaled_image) {
     817          unsigned int x, y;
     818          if (spu->scaled_width <= 1 || spu->scaled_height <= 1) {
     819            goto nothing_to_do;
     820          }
     821          switch(spu_aamode&15) {
     822          case 4:
     823          sws_spu_image(spu->scaled_image, spu->scaled_aimage,
     824                  spu->scaled_width, spu->scaled_height, spu->scaled_stride,
     825                  spu->image, spu->aimage, spu->width, spu->height, spu->stride);
     826          break;
     827          case 3:
     828          table_x = calloc(spu->scaled_width, sizeof(scale_pixel));
     829          table_y = calloc(spu->scaled_height, sizeof(scale_pixel));
     830          if (!table_x || !table_y) {
     831            mp_msg(MSGT_SPUDEC, MSGL_FATAL, "Fatal: spudec_draw_scaled: calloc failed\n");
     832          }
     833          scale_table(0, 0, spu->width - 1, spu->scaled_width - 1, table_x);
     834          scale_table(0, 0, spu->height - 1, spu->scaled_height - 1, table_y);
     835          for (y = 0; y < spu->scaled_height; y++)
     836            for (x = 0; x < spu->scaled_width; x++)
     837              scale_image(x, y, table_x, table_y, spu);
     838          free(table_x);
     839          free(table_y);
     840          break;
     841          case 0:
     842          /* no antialiasing */
     843          for (y = 0; y < spu->scaled_height; ++y) {
     844            int unscaled_y = y * 0x100 / scaley;
     845            int strides = spu->stride * unscaled_y;
     846            int scaled_strides = spu->scaled_stride * y;
     847            for (x = 0; x < spu->scaled_width; ++x) {
     848              int unscaled_x = x * 0x100 / scalex;
     849              spu->scaled_image[scaled_strides + x] = spu->image[strides + unscaled_x];
     850              spu->scaled_aimage[scaled_strides + x] = spu->aimage[strides + unscaled_x];
     851            }
     852          }
     853          break;
     854          case 1:
     855          {
     856            /* Intermediate antialiasing. */
     857            for (y = 0; y < spu->scaled_height; ++y) {
     858              const unsigned int unscaled_top = y * spu->orig_frame_height / dys;
     859              unsigned int unscaled_bottom = (y + 1) * spu->orig_frame_height / dys;
     860              if (unscaled_bottom >= spu->height)
     861                unscaled_bottom = spu->height - 1;
     862              for (x = 0; x < spu->scaled_width; ++x) {
     863                const unsigned int unscaled_left = x * spu->orig_frame_width / dxs;
     864                unsigned int unscaled_right = (x + 1) * spu->orig_frame_width / dxs;
     865                unsigned int color = 0;
     866                unsigned int alpha = 0;
     867                unsigned int walkx, walky;
     868                unsigned int base, tmp;
     869                if (unscaled_right >= spu->width)
     870                  unscaled_right = spu->width - 1;
     871                for (walky = unscaled_top; walky <= unscaled_bottom; ++walky)
     872                  for (walkx = unscaled_left; walkx <= unscaled_right; ++walkx) {
     873                    base = walky * spu->stride + walkx;
     874                    tmp = canon_alpha(spu->aimage[base]);
     875                    alpha += tmp;
     876                    color += tmp * spu->image[base];
     877                  }
     878                base = y * spu->scaled_stride + x;
     879                spu->scaled_image[base] = alpha ? color / alpha : 0;
     880                spu->scaled_aimage[base] =
     881                  alpha * (1 + unscaled_bottom - unscaled_top) * (1 + unscaled_right - unscaled_left);
     882                /* spu->scaled_aimage[base] =
     883                  alpha * dxs * dys / spu->orig_frame_width / spu->orig_frame_height; */
     884                if (spu->scaled_aimage[base]) {
     885                  spu->scaled_aimage[base] = 256 - spu->scaled_aimage[base];
     886                  if (spu->scaled_aimage[base] + spu->scaled_image[base] > 255)
     887                    spu->scaled_image[base] = 256 - spu->scaled_aimage[base];
     888                }
     889              }
     890            }
     891          }
     892          break;
     893          case 2:
     894          {
     895            /* Best antialiasing.  Very slow. */
     896            /* Any pixel (x, y) represents pixels from the original
     897               rectangular region comprised between the columns
     898               unscaled_y and unscaled_y + 0x100 / scaley and the rows
     899               unscaled_x and unscaled_x + 0x100 / scalex
     900
     901               The original rectangular region that the scaled pixel
     902               represents is cut in 9 rectangular areas like this:
     903               
     904               +---+-----------------+---+
     905               | 1 |        2        | 3 |
     906               +---+-----------------+---+
     907               |   |                 |   |
     908               | 4 |        5        | 6 |
     909               |   |                 |   |
     910               +---+-----------------+---+
     911               | 7 |        8        | 9 |
     912               +---+-----------------+---+
     913
     914               The width of the left column is at most one pixel and
     915               it is never null and its right column is at a pixel
     916               boundary.  The height of the top row is at most one
     917               pixel it is never null and its bottom row is at a
     918               pixel boundary. The width and height of region 5 are
     919               integral values.  The width of the right column is
     920               what remains and is less than one pixel.  The height
     921               of the bottom row is what remains and is less than
     922               one pixel.
     923
     924               The row above 1, 2, 3 is unscaled_y.  The row between
     925               1, 2, 3 and 4, 5, 6 is top_low_row.  The row between 4,
     926               5, 6 and 7, 8, 9 is (unsigned int)unscaled_y_bottom.
     927               The row beneath 7, 8, 9 is unscaled_y_bottom.
     928
     929               The column left of 1, 4, 7 is unscaled_x.  The column
     930               between 1, 4, 7 and 2, 5, 8 is left_right_column.  The
     931               column between 2, 5, 8 and 3, 6, 9 is (unsigned
     932               int)unscaled_x_right.  The column right of 3, 6, 9 is
     933               unscaled_x_right. */
     934            const double inv_scalex = (double) 0x100 / scalex;
     935            const double inv_scaley = (double) 0x100 / scaley;
     936            for (y = 0; y < spu->scaled_height; ++y) {
     937              const double unscaled_y = y * inv_scaley;
     938              const double unscaled_y_bottom = unscaled_y + inv_scaley;
     939              const unsigned int top_low_row = MIN(unscaled_y_bottom, unscaled_y + 1.0);
     940              const double top = top_low_row - unscaled_y;
     941              const unsigned int height = unscaled_y_bottom > top_low_row
     942                ? (unsigned int) unscaled_y_bottom - top_low_row
     943                : 0;
     944              const double bottom = unscaled_y_bottom > top_low_row
     945                ? unscaled_y_bottom - floor(unscaled_y_bottom)
     946                : 0.0;
     947              for (x = 0; x < spu->scaled_width; ++x) {
     948                const double unscaled_x = x * inv_scalex;
     949                const double unscaled_x_right = unscaled_x + inv_scalex;
     950                const unsigned int left_right_column = MIN(unscaled_x_right, unscaled_x + 1.0);
     951                const double left = left_right_column - unscaled_x;
     952                const unsigned int width = unscaled_x_right > left_right_column
     953                  ? (unsigned int) unscaled_x_right - left_right_column
     954                  : 0;
     955                const double right = unscaled_x_right > left_right_column
     956                  ? unscaled_x_right - floor(unscaled_x_right)
     957                  : 0.0;
     958                double color = 0.0;
     959                double alpha = 0.0;
     960                double tmp;
     961                unsigned int base;
     962                /* Now use these informations to compute a good alpha,
     963                   and lightness.  The sum is on each of the 9
     964                   region's surface and alpha and lightness.
     965
     966                  transformed alpha = sum(surface * alpha) / sum(surface)
     967                  transformed color = sum(surface * alpha * color) / sum(surface * alpha)
     968                */
     969                /* 1: top left part */
     970                base = spu->stride * (unsigned int) unscaled_y;
     971                tmp = left * top * canon_alpha(spu->aimage[base + (unsigned int) unscaled_x]);
     972                alpha += tmp;
     973                color += tmp * spu->image[base + (unsigned int) unscaled_x];
     974                /* 2: top center part */
     975                if (width > 0) {
     976                  unsigned int walkx;
     977                  for (walkx = left_right_column; walkx < (unsigned int) unscaled_x_right; ++walkx) {
     978                    base = spu->stride * (unsigned int) unscaled_y + walkx;
     979                    tmp = /* 1.0 * */ top * canon_alpha(spu->aimage[base]);
     980                    alpha += tmp;
     981                    color += tmp * spu->image[base];
     982                  }
     983                }
     984                /* 3: top right part */
     985                if (right > 0.0) {
     986                  base = spu->stride * (unsigned int) unscaled_y + (unsigned int) unscaled_x_right;
     987                  tmp = right * top * canon_alpha(spu->aimage[base]);
     988                  alpha += tmp;
     989                  color += tmp * spu->image[base];
     990                }
     991                /* 4: center left part */
     992                if (height > 0) {
     993                  unsigned int walky;
     994                  for (walky = top_low_row; walky < (unsigned int) unscaled_y_bottom; ++walky) {
     995                    base = spu->stride * walky + (unsigned int) unscaled_x;
     996                    tmp = left /* * 1.0 */ * canon_alpha(spu->aimage[base]);
     997                    alpha += tmp;
     998                    color += tmp * spu->image[base];
     999                  }
     1000                }
     1001                /* 5: center part */
     1002                if (width > 0 && height > 0) {
     1003                  unsigned int walky;
     1004                  for (walky = top_low_row; walky < (unsigned int) unscaled_y_bottom; ++walky) {
     1005                    unsigned int walkx;
     1006                    base = spu->stride * walky;
     1007                    for (walkx = left_right_column; walkx < (unsigned int) unscaled_x_right; ++walkx) {
     1008                      tmp = /* 1.0 * 1.0 * */ canon_alpha(spu->aimage[base + walkx]);
     1009                      alpha += tmp;
     1010                      color += tmp * spu->image[base + walkx];
     1011                    }
     1012                  }                 
     1013                }
     1014                /* 6: center right part */
     1015                if (right > 0.0 && height > 0) {
     1016                  unsigned int walky;
     1017                  for (walky = top_low_row; walky < (unsigned int) unscaled_y_bottom; ++walky) {
     1018                    base = spu->stride * walky + (unsigned int) unscaled_x_right;
     1019                    tmp = right /* * 1.0 */ * canon_alpha(spu->aimage[base]);
     1020                    alpha += tmp;
     1021                    color += tmp * spu->image[base];
     1022                  }
     1023                }
     1024                /* 7: bottom left part */
     1025                if (bottom > 0.0) {
     1026                  base = spu->stride * (unsigned int) unscaled_y_bottom + (unsigned int) unscaled_x;
     1027                  tmp = left * bottom * canon_alpha(spu->aimage[base]);
     1028                  alpha += tmp;
     1029                  color += tmp * spu->image[base];
     1030                }
     1031                /* 8: bottom center part */
     1032                if (width > 0 && bottom > 0.0) {
     1033                  unsigned int walkx;
     1034                  base = spu->stride * (unsigned int) unscaled_y_bottom;
     1035                  for (walkx = left_right_column; walkx < (unsigned int) unscaled_x_right; ++walkx) {
     1036                    tmp = /* 1.0 * */ bottom * canon_alpha(spu->aimage[base + walkx]);
     1037                    alpha += tmp;
     1038                    color += tmp * spu->image[base + walkx];
     1039                  }
     1040                }
     1041                /* 9: bottom right part */
     1042                if (right > 0.0 && bottom > 0.0) {
     1043                  base = spu->stride * (unsigned int) unscaled_y_bottom + (unsigned int) unscaled_x_right;
     1044                  tmp = right * bottom * canon_alpha(spu->aimage[base]);
     1045                  alpha += tmp;
     1046                  color += tmp * spu->image[base];
     1047                }
     1048                /* Finally mix these transparency and brightness information suitably */
     1049                base = spu->scaled_stride * y + x;
     1050                spu->scaled_image[base] = alpha > 0 ? color / alpha : 0;
     1051                spu->scaled_aimage[base] = alpha * scalex * scaley / 0x10000;
     1052                if (spu->scaled_aimage[base]) {
     1053                  spu->scaled_aimage[base] = 256 - spu->scaled_aimage[base];
     1054                  if (spu->scaled_aimage[base] + spu->scaled_image[base] > 255)
     1055                    spu->scaled_image[base] = 256 - spu->scaled_aimage[base];
     1056                }
     1057              }
     1058            }
     1059          }
     1060          }
     1061nothing_to_do:
     1062          /* Kludge: draw_alpha needs width multiple of 8. */
     1063          if (spu->scaled_width < spu->scaled_stride)
     1064            for (y = 0; y < spu->scaled_height; ++y) {
     1065              memset(spu->scaled_aimage + y * spu->scaled_stride + spu->scaled_width, 0,
     1066                     spu->scaled_stride - spu->scaled_width);
     1067            }
     1068          spu->scaled_frame_width = dxs;
     1069          spu->scaled_frame_height = dys;
     1070        }
     1071      }
     1072      if (spu->scaled_image){
    6021073        switch (spu_alignment) {
    6031074        case 0:
    604             bbox[3] = dys*sub_pos/100 + spu->height * scaley / 0x100;
    605             if (bbox[3] > dys) bbox[3] = dys;
    606             bbox[2] = bbox[3] - spu->height * scaley / 0x100;
    607             break;
    608         case 1:
    609             if (sub_pos < 50) {
    610                 bbox[2] = dys*sub_pos/100 - spu->height * scaley / 0x200;
    611                 if (bbox[2] < 0) bbox[2] = 0;
    612                 bbox[3] = bbox[2] + spu->height;
    613             } else {
    614                 bbox[3] = dys*sub_pos/100 + spu->height * scaley / 0x200;
    615                 if (bbox[3] > dys) bbox[3] = dys;
    616                 bbox[2] = bbox[3] - spu->height * scaley / 0x100;
    617             }
    618             break;
     1075          spu->scaled_start_row = dys*sub_pos/100;
     1076          if (spu->scaled_start_row + spu->scaled_height > dys)
     1077            spu->scaled_start_row = dys - spu->scaled_height;
     1078          break;
     1079        case 1:
     1080          spu->scaled_start_row = dys*sub_pos/100 - spu->scaled_height/2;
     1081          if (sub_pos < 50) {
     1082            if (spu->scaled_start_row < 0) spu->scaled_start_row = 0;
     1083          } else {
     1084            if (spu->scaled_start_row + spu->scaled_height > dys)
     1085              spu->scaled_start_row = dys - spu->scaled_height;
     1086          }
     1087          break;
    6191088        case 2:
    620             bbox[2] = dys*sub_pos/100 - spu->height * scaley / 0x100;
    621             if (bbox[2] < 0) bbox[2] = 0;
    622             bbox[3] = bbox[2] + spu->height;
    623             break;
    624         default: /* -1 */
    625             bbox[2] = spu->start_row * scaley / 0x100;
    626             bbox[3] = spu->start_row * scaley / 0x100 + spu->height * scaley / 0x100;
    627             break;
    628         }
    629     }
    630 }
    631 /* transform mplayer's alpha value into an opacity value that is linear */
    632 static inline int canon_alpha(int alpha)
    633 {
    634     return alpha ? 256 - alpha : 0;
    635 }
    636 
    637 typedef struct {
    638     unsigned position;
    639     unsigned left_up;
    640     unsigned right_down;
    641 }scale_pixel;
    642 
    643 
    644 static void scale_table(unsigned int start_src, unsigned int start_tar, unsigned int end_src, unsigned int end_tar, scale_pixel * table)
    645 {
    646     unsigned int t;
    647     unsigned int delta_src = end_src - start_src;
    648     unsigned int delta_tar = end_tar - start_tar;
    649     int src = 0;
    650     int src_step;
    651     if (delta_src == 0 || delta_tar == 0) {
    652         return;
    653     }
    654     src_step = (delta_src << 16) / delta_tar >>1;
    655     for (t = 0; t<=delta_tar; src += (src_step << 1), t++){
    656         table[t].position= MIN(src >> 16, end_src - 1);
    657         table[t].right_down = src & 0xffff;
    658         table[t].left_up = 0x10000 - table[t].right_down;
    659     }
    660 }
    661 
    662 /* bilinear scale, similar to vobsub's code */
    663 static void scale_image(int x, int y, scale_pixel* table_x, scale_pixel* table_y, spudec_handle_t * spu)
    664 {
    665     int alpha[4];
    666     int color[4];
    667     unsigned int scale[4];
    668     int base = table_y[y].position * spu->stride + table_x[x].position;
    669     int scaled = y * spu->scaled_stride + x;
    670     alpha[0] = canon_alpha(spu->aimage[base]);
    671     alpha[1] = canon_alpha(spu->aimage[base + 1]);
    672     alpha[2] = canon_alpha(spu->aimage[base + spu->stride]);
    673     alpha[3] = canon_alpha(spu->aimage[base + spu->stride + 1]);
    674     color[0] = spu->image[base];
    675     color[1] = spu->image[base + 1];
    676     color[2] = spu->image[base + spu->stride];
    677     color[3] = spu->image[base + spu->stride + 1];
    678     scale[0] = (table_x[x].left_up * table_y[y].left_up >> 16) * alpha[0];
    679     scale[1] = (table_x[x].right_down * table_y[y].left_up >>16) * alpha[1];
    680     scale[2] = (table_x[x].left_up * table_y[y].right_down >> 16) * alpha[2];
    681     scale[3] = (table_x[x].right_down * table_y[y].right_down >> 16) * alpha[3];
    682     spu->scaled_image[scaled] = (color[0] * scale[0] + color[1] * scale[1] + color[2] * scale[2] + color[3] * scale[3])>>24;
    683     spu->scaled_aimage[scaled] = (scale[0] + scale[1] + scale[2] + scale[3]) >> 16;
    684     if (spu->scaled_aimage[scaled]){
    685         spu->scaled_aimage[scaled] = 256 - spu->scaled_aimage[scaled];
    686         if(spu->scaled_aimage[scaled] + spu->scaled_image[scaled] > 255)
    687             spu->scaled_image[scaled] = 256 - spu->scaled_aimage[scaled];
    688     }
    689 }
     1089          spu->scaled_start_row = dys*sub_pos/100 - spu->scaled_height;
     1090          if (spu->scaled_start_row < 0) spu->scaled_start_row = 0;
     1091          break;
     1092        }
     1093        draw_alpha(spu->scaled_start_col, spu->scaled_start_row, spu->scaled_width, spu->scaled_height,
     1094                   spu->scaled_image, spu->scaled_aimage, spu->scaled_stride);
     1095        spu->spu_changed = 0;
     1096      }
     1097    }
     1098  }
     1099  else
     1100  {
     1101    mp_msg(MSGT_SPUDEC,MSGL_DBG2,"SPU not displayed: start_pts=%d  end_pts=%d  now_pts=%d\n",
     1102        spu->start_pts, spu->end_pts, spu->now_pts);
     1103  }
     1104}
     1105
     1106void spudec_update_palette(void * this, unsigned int *palette)
     1107{
     1108  spudec_handle_t *spu = (spudec_handle_t *) this;
     1109  if (spu && palette) {
     1110      memcpy(spu->global_palette, palette, sizeof(spu->global_palette));
    6901111#if 0
    691 void sws_spu_image(unsigned char *d1, unsigned char *d2, int dw, int dh, int ds,
    692                    unsigned char *s1, unsigned char *s2, int sw, int sh, int ss)
    693 {
    694     struct SwsContext *ctx;
    695     static SwsFilter filter;
    696     static int firsttime = 1;
    697     static float oldvar;
    698     int i;
    699 
    700     if (!firsttime && oldvar != spu_gaussvar) sws_freeVec(filter.lumH);
    701     if (firsttime) {
    702         filter.lumH = filter.lumV =
    703             filter.chrH = filter.chrV = sws_getGaussianVec(spu_gaussvar, 3.0);
    704         sws_normalizeVec(filter.lumH, 1.0);
    705         firsttime = 0;
    706         oldvar = spu_gaussvar;
    707     }
    708 
    709     ctx=sws_getContext(sw, sh, IMGFMT_Y800, dw, dh, IMGFMT_Y800, SWS_GAUSS, &filter, NULL);
    710     sws_scale(ctx,&s1,&ss,0,sh,&d1,&ds);
    711     for (i=ss*sh-1; i>=0; i--) if (!s2[i]) s2[i] = 255; //else s2[i] = 1;
    712     sws_scale(ctx,&s2,&ss,0,sh,&d2,&ds);
    713     for (i=ds*dh-1; i>=0; i--) if (d2[i]==0) d2[i] = 1; else if (d2[i]==255) d2[i] = 0;
    714     sws_freeContext(ctx);
    715 }
     1112    if(spu->hw_spu)
     1113        spu->hw_spu->control(VOCTRL_SET_SPU_PALETTE,spu->global_palette);
    7161114#endif
    717 void spudec_draw_scaled(void *me, unsigned int dxs, unsigned int dys, void (*draw_alpha)(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride))
    718 {
    719     spudec_handle_t *spu = (spudec_handle_t *)me;
    720     scale_pixel *table_x;
    721     scale_pixel *table_y;
    722 
    723     if (spu->start_pts <= spu->now_pts && spu->now_pts < spu->end_pts) {
    724 
    725         // check if only forced subtitles are requested
    726         if( (spu->forced_subs_only) && !(spu->is_forced_sub) ){
    727             return;
    728         }
    729 
    730         if (!(spu_aamode&16) && (spu->orig_frame_width == 0 || spu->orig_frame_height == 0
    731                                  || (spu->orig_frame_width == dxs && spu->orig_frame_height == dys))) {
    732             if (spu->image)
    733             {
    734                 draw_alpha(spu->start_col, spu->start_row, spu->width, spu->height,
    735                            spu->image, spu->aimage, spu->stride);
    736                 spu->spu_changed = 0;
    737             }
    738         }
    739         else {
    740             if (spu->scaled_frame_width != dxs || spu->scaled_frame_height != dys) {    /* Resizing is needed */
    741                 /* scaled_x = scalex * x / 0x100
    742                  scaled_y = scaley * y / 0x100
    743                  order of operations is important because of rounding. */
    744                 unsigned int scalex = 0x100 * dxs / spu->orig_frame_width;
    745                 unsigned int scaley = 0x100 * dys / spu->orig_frame_height;
    746                 spu->scaled_start_col = spu->start_col * scalex / 0x100;
    747                 spu->scaled_start_row = spu->start_row * scaley / 0x100;
    748                 spu->scaled_width = spu->width * scalex / 0x100;
    749                 spu->scaled_height = spu->height * scaley / 0x100;
    750                 /* Kludge: draw_alpha needs width multiple of 8 */
    751                 spu->scaled_stride = (spu->scaled_width + 7) & ~7;
    752                 if (spu->scaled_image_size < spu->scaled_stride * spu->scaled_height) {
    753                     if (spu->scaled_image) {
    754                         free(spu->scaled_image);
    755                         spu->scaled_image_size = 0;
    756                     }
    757                     spu->scaled_image = malloc(2 * spu->scaled_stride * spu->scaled_height);
    758                     if (spu->scaled_image) {
    759                         spu->scaled_image_size = spu->scaled_stride * spu->scaled_height;
    760                         spu->scaled_aimage = spu->scaled_image + spu->scaled_image_size;
    761                     }
    762                 }
    763                 if (spu->scaled_image) {
    764                     unsigned int x, y;
    765                     /* Kludge: draw_alpha needs width multiple of 8. */
    766                     if (spu->scaled_width < spu->scaled_stride)
    767                         for (y = 0; y < spu->scaled_height; ++y) {
    768                             memset(spu->scaled_aimage + y * spu->scaled_stride + spu->scaled_width, 0,
    769                                    spu->scaled_stride - spu->scaled_width);
    770                             /* FIXME: Why is this one needed? */
    771                             memset(spu->scaled_image + y * spu->scaled_stride + spu->scaled_width, 0,
    772                                    spu->scaled_stride - spu->scaled_width);
    773                         }
    774                     if (spu->scaled_width <= 1 || spu->scaled_height <= 1) {
    775                         goto nothing_to_do;
    776                     }
    777                     switch(spu_aamode&15) {
    778                     case 4:
    779 #if 0
    780                         sws_spu_image(spu->scaled_image, spu->scaled_aimage,
    781                                       spu->scaled_width, spu->scaled_height, spu->scaled_stride,
    782                                       spu->image, spu->aimage, spu->width, spu->height, spu->stride);
    783                         break;
    784 #endif
    785                     case 3:
    786                         table_x = calloc(spu->scaled_width, sizeof(scale_pixel));
    787                         table_y = calloc(spu->scaled_height, sizeof(scale_pixel));
    788                         if (!table_x || !table_y) {
    789                             dprintf("Fatal: spudec_draw_scaled: calloc failed\n");
    790                         }
    791                         scale_table(0, 0, spu->width - 1, spu->scaled_width - 1, table_x);
    792                         scale_table(0, 0, spu->height - 1, spu->scaled_height - 1, table_y);
    793                         for (y = 0; y < spu->scaled_height; y++)
    794                             for (x = 0; x < spu->scaled_width; x++)
    795                                 scale_image(x, y, table_x, table_y, spu);
    796                         free(table_x);
    797                         free(table_y);
    798                         break;
    799                     case 0:
    800                         /* no antialiasing */
    801                         for (y = 0; y < spu->scaled_height; ++y) {
    802                             int unscaled_y = y * 0x100 / scaley;
    803                             int strides = spu->stride * unscaled_y;
    804                             int scaled_strides = spu->scaled_stride * y;
    805                             for (x = 0; x < spu->scaled_width; ++x) {
    806                                 int unscaled_x = x * 0x100 / scalex;
    807                                 spu->scaled_image[scaled_strides + x] = spu->image[strides + unscaled_x];
    808                                 spu->scaled_aimage[scaled_strides + x] = spu->aimage[strides + unscaled_x];
    809                             }
    810                         }
    811                         break;
    812                     case 1:
    813                         {
    814                             /* Intermediate antialiasing. */
    815                             for (y = 0; y < spu->scaled_height; ++y) {
    816                                 const unsigned int unscaled_top = y * spu->orig_frame_height / dys;
    817                                 unsigned int unscaled_bottom = (y + 1) * spu->orig_frame_height / dys;
    818                                 if (unscaled_bottom >= spu->height)
    819                                     unscaled_bottom = spu->height - 1;
    820                                 for (x = 0; x < spu->scaled_width; ++x) {
    821                                     const unsigned int unscaled_left = x * spu->orig_frame_width / dxs;
    822                                     unsigned int unscaled_right = (x + 1) * spu->orig_frame_width / dxs;
    823                                     unsigned int color = 0;
    824                                     unsigned int alpha = 0;
    825                                     unsigned int walkx, walky;
    826                                     unsigned int base, tmp;
    827                                     if (unscaled_right >= spu->width)
    828                                         unscaled_right = spu->width - 1;
    829                                     for (walky = unscaled_top; walky <= unscaled_bottom; ++walky)
    830                                         for (walkx = unscaled_left; walkx <= unscaled_right; ++walkx) {
    831                                             base = walky * spu->stride + walkx;
    832                                             tmp = canon_alpha(spu->aimage[base]);
    833                                             alpha += tmp;
    834                                             color += tmp * spu->image[base];
    835                                         }
    836                                     base = y * spu->scaled_stride + x;
    837                                     spu->scaled_image[base] = alpha ? color / alpha : 0;
    838                                     spu->scaled_aimage[base] =
    839                                         alpha * (1 + unscaled_bottom - unscaled_top) * (1 + unscaled_right - unscaled_left);
    840                                     /* spu->scaled_aimage[base] =
    841                                      alpha * dxs * dys / spu->orig_frame_width / spu->orig_frame_height; */
    842                                     if (spu->scaled_aimage[base]) {
    843                                         spu->scaled_aimage[base] = 256 - spu->scaled_aimage[base];
    844                                         if (spu->scaled_aimage[base] + spu->scaled_image[base] > 255)
    845                                             spu->scaled_image[base] = 256 - spu->scaled_aimage[base];
    846                                     }
    847                                 }
    848                             }
    849                         }
    850                         break;
    851                     case 2:
    852                         {
    853                             /* Best antialiasing.  Very slow. */
    854                             /* Any pixel (x, y) represents pixels from the original
    855                              rectangular region comprised between the columns
    856                              unscaled_y and unscaled_y + 0x100 / scaley and the rows
    857                              unscaled_x and unscaled_x + 0x100 / scalex
    858 
    859                              The original rectangular region that the scaled pixel
    860                              represents is cut in 9 rectangular areas like this:
    861 
    862                              +---+-----------------+---+
    863                              | 1 |        2        | 3 |
    864                              +---+-----------------+---+
    865                              |   |                 |   |
    866                              | 4 |        5        | 6 |
    867                              |   |                 |   |
    868                              +---+-----------------+---+
    869                              | 7 |        8        | 9 |
    870                              +---+-----------------+---+
    871 
    872                              The width of the left column is at most one pixel and
    873                              it is never null and its right column is at a pixel
    874                              boundary.  The height of the top row is at most one
    875                              pixel it is never null and its bottom row is at a
    876                              pixel boundary. The width and height of region 5 are
    877                              integral values.  The width of the right column is
    878                              what remains and is less than one pixel.  The height
    879                              of the bottom row is what remains and is less than
    880                              one pixel.
    881 
    882                              The row above 1, 2, 3 is unscaled_y.  The row between
    883                              1, 2, 3 and 4, 5, 6 is top_low_row.  The row between 4,
    884                              5, 6 and 7, 8, 9 is (unsigned int)unscaled_y_bottom.
    885                              The row beneath 7, 8, 9 is unscaled_y_bottom.
    886 
    887                              The column left of 1, 4, 7 is unscaled_x.  The column
    888                              between 1, 4, 7 and 2, 5, 8 is left_right_column.  The
    889                              column between 2, 5, 8 and 3, 6, 9 is (unsigned
    890                              int)unscaled_x_right.  The column right of 3, 6, 9 is
    891                              unscaled_x_right. */
    892                             const double inv_scalex = (double) 0x100 / scalex;
    893                             const double inv_scaley = (double) 0x100 / scaley;
    894                             for (y = 0; y < spu->scaled_height; ++y) {
    895                                 const double unscaled_y = y * inv_scaley;
    896                                 const double unscaled_y_bottom = unscaled_y + inv_scaley;
    897                                 const unsigned int top_low_row = MIN(unscaled_y_bottom, unscaled_y + 1.0);
    898                                 const double top = top_low_row - unscaled_y;
    899                                 const unsigned int height = unscaled_y_bottom > top_low_row
    900                                     ? (unsigned int) unscaled_y_bottom - top_low_row
    901                                     : 0;
    902                                 const double bottom = unscaled_y_bottom > top_low_row
    903                                     ? unscaled_y_bottom - floor(unscaled_y_bottom)
    904                                     : 0.0;
    905                                 for (x = 0; x < spu->scaled_width; ++x) {
    906                                     const double unscaled_x = x * inv_scalex;
    907                                     const double unscaled_x_right = unscaled_x + inv_scalex;
    908                                     const unsigned int left_right_column = MIN(unscaled_x_right, unscaled_x + 1.0);
    909                                     const double left = left_right_column - unscaled_x;
    910                                     const unsigned int width = unscaled_x_right > left_right_column
    911                                         ? (unsigned int) unscaled_x_right - left_right_column
    912                                         : 0;
    913                                     const double right = unscaled_x_right > left_right_column
    914                                         ? unscaled_x_right - floor(unscaled_x_right)
    915                                         : 0.0;
    916                                     double color = 0.0;
    917                                     double alpha = 0.0;
    918                                     double tmp;
    919                                     unsigned int base;
    920                                     /* Now use these informations to compute a good alpha,
    921                                      and lightness.  The sum is on each of the 9
    922                                      region's surface and alpha and lightness.
    923 
    924                                      transformed alpha = sum(surface * alpha) / sum(surface)
    925                                      transformed color = sum(surface * alpha * color) / sum(surface * alpha)
    926                                      */
    927                                     /* 1: top left part */
    928                                     base = spu->stride * (unsigned int) unscaled_y;
    929                                     tmp = left * top * canon_alpha(spu->aimage[base + (unsigned int) unscaled_x]);
    930                                     alpha += tmp;
    931                                     color += tmp * spu->image[base + (unsigned int) unscaled_x];
    932                                     /* 2: top center part */
    933                                     if (width > 0) {
    934                                         unsigned int walkx;
    935                                         for (walkx = left_right_column; walkx < (unsigned int) unscaled_x_right; ++walkx) {
    936                                             base = spu->stride * (unsigned int) unscaled_y + walkx;
    937                                             tmp = /* 1.0 * */ top * canon_alpha(spu->aimage[base]);
    938                                             alpha += tmp;
    939                                             color += tmp * spu->image[base];
    940                                         }
    941                                     }
    942                                     /* 3: top right part */
    943                                     if (right > 0.0) {
    944                                         base = spu->stride * (unsigned int) unscaled_y + (unsigned int) unscaled_x_right;
    945                                         tmp = right * top * canon_alpha(spu->aimage[base]);
    946                                         alpha += tmp;
    947                                         color += tmp * spu->image[base];
    948                                     }
    949                                     /* 4: center left part */
    950                                     if (height > 0) {
    951                                         unsigned int walky;
    952                                         for (walky = top_low_row; walky < (unsigned int) unscaled_y_bottom; ++walky) {
    953                                             base = spu->stride * walky + (unsigned int) unscaled_x;
    954                                             tmp = left /* * 1.0 */ * canon_alpha(spu->aimage[base]);
    955                                             alpha += tmp;
    956                                             color += tmp * spu->image[base];
    957                                         }
    958                                     }
    959                                     /* 5: center part */
    960                                     if (width > 0 && height > 0) {
    961                                         unsigned int walky;
    962                                         for (walky = top_low_row; walky < (unsigned int) unscaled_y_bottom; ++walky) {
    963                                             unsigned int walkx;
    964                                             base = spu->stride * walky;
    965                                             for (walkx = left_right_column; walkx < (unsigned int) unscaled_x_right; ++walkx) {
    966                                                 tmp = /* 1.0 * 1.0 * */ canon_alpha(spu->aimage[base + walkx]);
    967                                                 alpha += tmp;
    968                                                 color += tmp * spu->image[base + walkx];
    969                                             }
    970                                         }
    971                                     }
    972                                     /* 6: center right part */
    973                                     if (right > 0.0 && height > 0) {
    974                                         unsigned int walky;
    975                                         for (walky = top_low_row; walky < (unsigned int) unscaled_y_bottom; ++walky) {
    976                                             base = spu->stride * walky + (unsigned int) unscaled_x_right;
    977                                             tmp = right /* * 1.0 */ * canon_alpha(spu->aimage[base]);
    978                                             alpha += tmp;
    979                                             color += tmp * spu->image[base];
    980                                         }
    981                                     }
    982                                     /* 7: bottom left part */
    983                                     if (bottom > 0.0) {
    984                                         base = spu->stride * (unsigned int) unscaled_y_bottom + (unsigned int) unscaled_x;
    985                                         tmp = left * bottom * canon_alpha(spu->aimage[base]);
    986                                         alpha += tmp;
    987                                         color += tmp * spu->image[base];
    988                                     }
    989                                     /* 8: bottom center part */
    990                                     if (width > 0 && bottom > 0.0) {
    991                                         unsigned int walkx;
    992                                         base = spu->stride * (unsigned int) unscaled_y_bottom;
    993                                         for (walkx = left_right_column; walkx < (unsigned int) unscaled_x_right; ++walkx) {
    994                                             tmp = /* 1.0 * */ bottom * canon_alpha(spu->aimage[base + walkx]);
    995                                             alpha += tmp;
    996                                             color += tmp * spu->image[base + walkx];
    997                                         }
    998                                     }
    999                                     /* 9: bottom right part */
    1000                                     if (right > 0.0 && bottom > 0.0) {
    1001                                         base = spu->stride * (unsigned int) unscaled_y_bottom + (unsigned int) unscaled_x_right;
    1002                                         tmp = right * bottom * canon_alpha(spu->aimage[base]);
    1003                                         alpha += tmp;
    1004                                         color += tmp * spu->image[base];
    1005                                     }
    1006                                     /* Finally mix these transparency and brightness information suitably */
    1007                                     base = spu->scaled_stride * y + x;
    1008                                     spu->scaled_image[base] = alpha > 0 ? color / alpha : 0;
    1009                                     spu->scaled_aimage[base] = alpha * scalex * scaley / 0x10000;
    1010                                     if (spu->scaled_aimage[base]) {
    1011                                         spu->scaled_aimage[base] = 256 - spu->scaled_aimage[base];
    1012                                         if (spu->scaled_aimage[base] + spu->scaled_image[base] > 255)
    1013                                             spu->scaled_image[base] = 256 - spu->scaled_aimage[base];
    1014                                     }
    1015                                 }
    1016                             }
    1017                         }
    1018                     }
    1019                 nothing_to_do:
    1020                     spu->scaled_frame_width = dxs;
    1021                     spu->scaled_frame_height = dys;
    1022                 }
    1023             }
    1024             if (spu->scaled_image){
    1025                 switch (spu_alignment) {
    1026                 case 0:
    1027                     spu->scaled_start_row = dys*sub_pos/100;
    1028                     if (spu->scaled_start_row + spu->scaled_height > dys)
    1029                         spu->scaled_start_row = dys - spu->scaled_height;
    1030                     break;
    1031                 case 1:
    1032                     spu->scaled_start_row = dys*sub_pos/100 - spu->scaled_height/2;
    1033                     if (sub_pos < 50) {
    1034                         if (spu->scaled_start_row < 0) spu->scaled_start_row = 0;
    1035                     } else {
    1036                         if (spu->scaled_start_row + spu->scaled_height > dys)
    1037                             spu->scaled_start_row = dys - spu->scaled_height;
    1038                     }
    1039                     break;
    1040                 case 2:
    1041                     spu->scaled_start_row = dys*sub_pos/100 - spu->scaled_height;
    1042                     if (spu->scaled_start_row < 0) spu->scaled_start_row = 0;
    1043                     break;
    1044                 }
    1045                 draw_alpha(spu->scaled_start_col, spu->scaled_start_row, spu->scaled_width, spu->scaled_height,
    1046                            spu->scaled_image, spu->scaled_aimage, spu->scaled_stride);
    1047                 spu->spu_changed = 0;
    1048             }
    1049         }
    1050     }
    1051     else
    1052     {
    1053         dprintf("SPU not displayed: start_pts=%d  end_pts=%d  now_pts=%d\n",
    1054                 spu->start_pts, spu->end_pts, spu->now_pts);
    1055     }
    1056 }
    1057 
    1058 void spudec_update_palette(void * this, unsigned int *palette)
    1059 {
    1060     spudec_handle_t *spu = (spudec_handle_t *) this;
    1061     if (spu && palette) {
    1062         memcpy(spu->global_palette, palette, sizeof(spu->global_palette));
    1063 #if 0
    1064         if(spu->hw_spu)
    1065             spu->hw_spu->control(VOCTRL_SET_SPU_PALETTE,spu->global_palette);
    1066 #endif
    1067     }
     1115  }
    10681116}
    10691117
    10701118void spudec_set_font_factor(void * this, double factor)
    10711119{
    1072     spudec_handle_t *spu = (spudec_handle_t *) this;
    1073     spu->font_start_level = (int)(0xF0-(0xE0*factor));
     1120  spudec_handle_t *spu = (spudec_handle_t *) this;
     1121  spu->font_start_level = (int)(0xF0-(0xE0*factor));
    10741122}
    10751123
    10761124void *spudec_new_scaled(unsigned int *palette, unsigned int frame_width, unsigned int frame_height)
    10771125{
    1078     return spudec_new_scaled_vobsub(palette, NULL, 0, frame_width, frame_height);
     1126  return spudec_new_scaled_vobsub(palette, NULL, 0, frame_width, frame_height);
    10791127}
    10801128
    … …  
    10821130void *spudec_new_scaled_vobsub(unsigned int *palette, unsigned int *cuspal, unsigned int custom, unsigned int frame_width, unsigned int frame_height)
    10831131{
    1084     spudec_handle_t *this = calloc(1, sizeof(spudec_handle_t));
    1085     if (this){
    1086         //(fprintf(stderr,"VobSub Custom Palette: %d,%d,%d,%d", this->cuspal[0], this->cuspal[1], this->cuspal[2],this->cuspal[3]);
    1087         this->packet = NULL;
    1088         this->image = NULL;
    1089         this->scaled_image = NULL;
    1090         /* XXX Although the video frame is some size, the SPU frame is
    1091          always maximum size i.e. 720 wide and 576 or 480 high */
    1092         this->orig_frame_width = 720;
    1093         this->orig_frame_height = (frame_height == 480 || frame_height == 240) ? 480 : 576;
    1094         this->custom = custom;
    1095         // set up palette:
    1096         this->auto_palette = 1;
    1097         if (palette){
    1098             memcpy(this->global_palette, palette, sizeof(this->global_palette));
    1099             this->auto_palette = 0;
    1100         }
    1101         this->custom = custom;
    1102         if (custom && cuspal) {
    1103             memcpy(this->cuspal, cuspal, sizeof(this->cuspal));
    1104             this->auto_palette = 0;
    1105         }
    1106         // forced subtitles default: show all subtitles
    1107         this->forced_subs_only=0;
    1108         this->is_forced_sub=0;
    1109     }
    1110     else
    1111         dprintf("FATAL: spudec_init: calloc");
    1112     return this;
     1132  spudec_handle_t *this = calloc(1, sizeof(spudec_handle_t));
     1133  if (this){
     1134    //(fprintf(stderr,"VobSub Custom Palette: %d,%d,%d,%d", this->cuspal[0], this->cuspal[1], this->cuspal[2],this->cuspal[3]);
     1135    this->packet = NULL;
     1136    this->image = NULL;
     1137    this->scaled_image = NULL;
     1138    /* XXX Although the video frame is some size, the SPU frame is
     1139       always maximum size i.e. 720 wide and 576 or 480 high */
     1140    this->orig_frame_width = 720;
     1141    this->orig_frame_height = (frame_height == 480 || frame_height == 240) ? 480 : 576;
     1142    this->custom = custom;
     1143    // set up palette:
     1144    this->auto_palette = 1;
     1145    if (palette){
     1146      memcpy(this->global_palette, palette, sizeof(this->global_palette));
     1147      this->auto_palette = 0;
     1148    }
     1149    this->custom = custom;
     1150    if (custom && cuspal) {
     1151      memcpy(this->cuspal, cuspal, sizeof(this->cuspal));
     1152      this->auto_palette = 0;
     1153    }
     1154    // forced subtitles default: show all subtitles
     1155    this->forced_subs_only=0;
     1156    this->is_forced_sub=0;
     1157  }
     1158  else
     1159    mp_msg(MSGT_SPUDEC,MSGL_FATAL, "FATAL: spudec_init: calloc");
     1160  return this;
    11131161}
    11141162
    … …  
    11201168void spudec_free(void *this)
    11211169{
    1122     spudec_handle_t *spu = (spudec_handle_t*)this;
    1123     if (spu) {
    1124         while (spu->queue_head)
    1125             spudec_free_packet(spudec_dequeue_packet(spu));
    1126         if (spu->packet)
    1127             free(spu->packet);
    1128         if (spu->scaled_image)
    1129             free(spu->scaled_image);
    1130         if (spu->image)
    1131             free(spu->image);
    1132         free(spu);
    1133     }
     1170  spudec_handle_t *spu = (spudec_handle_t*)this;
     1171  if (spu) {
     1172    while (spu->queue_head)
     1173      spudec_free_packet(spudec_dequeue_packet(spu));
     1174    if (spu->packet)
     1175      free(spu->packet);
     1176    if (spu->scaled_image)
     1177        free(spu->scaled_image);
     1178    if (spu->image)
     1179      free(spu->image);
     1180    free(spu);
     1181  }
    11341182}
    11351183#if 0
    11361184void spudec_set_hw_spu(void *this, vo_functions_t *hw_spu)
    11371185{
    1138     spudec_handle_t *spu = (spudec_handle_t*)this;
    1139     if (!spu)
    1140         return;
    1141     spu->hw_spu = hw_spu;
    1142     hw_spu->control(VOCTRL_SET_SPU_PALETTE,spu->global_palette);
     1186  spudec_handle_t *spu = (spudec_handle_t*)this;
     1187  if (!spu)
     1188    return;
     1189  spu->hw_spu = hw_spu;
     1190  hw_spu->control(VOCTRL_SET_SPU_PALETTE,spu->global_palette);
    11431191}
    11441192#endif

  • TabularUnified trunk/gui/spudec.h

    r64 r269  
    1 #ifndef _SPUDEC_H
    2 #define _SPUDEC_H
     1#ifndef _MPLAYER_SPUDEC_H
     2#define _MPLAYER_SPUDEC_H
    33
    44//#include "libvo/video_out.h"
    5 typedef struct packet_t packet_t;
    6 struct packet_t {
    7     unsigned char *packet;
    8     unsigned int palette[4];
    9     unsigned int alpha[4];
    10     unsigned int control_start; /* index of start of control data */
    11     unsigned int current_nibble[2]; /* next data nibble (4 bits) to be
    12     processed (for RLE decoding) for
    13     even and odd lines */
    14     int deinterlace_oddness;    /* 0 or 1, index into current_nibble */
    15     unsigned int start_col, end_col;
    16     unsigned int start_row, end_row;
    17     unsigned int width, height, stride;
    18     unsigned int start_pts, end_pts;
    19     packet_t *next;
    20 };
    215
    22 typedef struct {
    23     packet_t *queue_head;
    24     packet_t *queue_tail;
    25     unsigned int global_palette[16];
    26     unsigned int orig_frame_width, orig_frame_height;
    27     unsigned char* packet;
    28     size_t packet_reserve;      /* size of the memory pointed to by packet */
    29     unsigned int packet_offset; /* end of the currently assembled fragment */
    30     unsigned int packet_size;   /* size of the packet once all fragments are assembled */
    31     unsigned int packet_pts;    /* PTS for this packet */
    32     unsigned int palette[4];
    33     unsigned int alpha[4];
    34     unsigned int cuspal[4];
    35     unsigned int custom;
    36     unsigned int now_pts;
    37     unsigned int start_pts, end_pts;
    38     unsigned int start_col, end_col;
    39     unsigned int start_row, end_row;
    40     unsigned int width, height, stride;
    41     size_t image_size;          /* Size of the image buffer */
    42     unsigned char *image;               /* Grayscale value */
    43     unsigned char *aimage;      /* Alpha value */
    44     unsigned int scaled_frame_width, scaled_frame_height;
    45     unsigned int scaled_start_col, scaled_start_row;
    46     unsigned int scaled_width, scaled_height, scaled_stride;
    47     size_t scaled_image_size;
    48     unsigned char *scaled_image;
    49     unsigned char *scaled_aimage;
    50     int auto_palette; /* 1 if we lack a palette and must use an heuristic. */
    51     int font_start_level;  /* Darkest value used for the computed font */
    52     void *hw_spu;
    53     int spu_changed;
    54     unsigned int forced_subs_only;     /* flag: 0=display all subtitle, !0 display only forced subtitles */
    55     unsigned int is_forced_sub;         /* true if current subtitle is a forced subtitle */
    56 } spudec_handle_t;
    57 
    58 void spudec_heartbeat(void *that, unsigned int pts100);
    59 void spudec_assemble(void *that, unsigned char *packet, unsigned int len, unsigned int pts100);
    60 void spudec_draw(void *that, void (*draw_alpha)(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride));
    61 void spudec_draw_scaled(void *that, unsigned int dxs, unsigned int dys, void (*draw_alpha)(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride));
    62 void spudec_update_palette(void *that, unsigned int *palette);
     6void spudec_heartbeat(void *me, unsigned int pts100);
     7void spudec_assemble(void *me, unsigned char *packet, unsigned int len, unsigned int pts100);
     8void spudec_draw(void *me, void (*draw_alpha)(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride));
     9void spudec_draw_scaled(void *me, unsigned int dxs, unsigned int dys, void (*draw_alpha)(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride));
     10void spudec_update_palette(void *me, unsigned int *palette);
    6311void *spudec_new_scaled(unsigned int *palette, unsigned int frame_width, unsigned int frame_height);
    6412void *spudec_new_scaled_vobsub(unsigned int *palette, unsigned int *cuspal, unsigned int custom, unsigned int frame_width, unsigned int frame_height);
    6513void *spudec_new(unsigned int *palette);
    66 void spudec_free(void *that);
    67 void spudec_reset(void *that);  // called after seek
    68 int spudec_visible(void *that); // check if spu is visible
    69 void spudec_set_font_factor(void * that, double factor); // sets the equivalent to ffactor
    70 //void spudec_set_hw_spu(void *this, vo_functions_t *hw_spu);
    71 int spudec_changed(void *that);
     14void spudec_free(void *me);
     15void spudec_reset(void *me);    // called after seek
     16int spudec_visible(void *me); // check if spu is visible
     17void spudec_set_font_factor(void *me, double factor); // sets the equivalent to ffactor
     18//void spudec_set_hw_spu(void *me, vo_functions_t *hw_spu);
     19int spudec_changed(void *me);
    7220void spudec_calc_bbox(void *me, unsigned int dxs, unsigned int dys, unsigned int* bbox);
    73 void spudec_draw_scaled(void *me, unsigned int dxs, unsigned int dys, void (*draw_alpha)(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride));
    74 void spudec_set_forced_subs_only(void * const that, const unsigned int flag);
     21//void spudec_draw_scaled(void *me, unsigned int dxs, unsigned int dys, void (*draw_alpha)(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride));
     22void spudec_set_forced_subs_only(void * const me, const unsigned int flag);
    7523#endif
    7624

  • TabularUnified trunk/gui/version.h

    r267 r269  
    1 #define VERSION "28 Nov 2006"
     1#define VERSION "3 Dec 2006"

  • TabularUnified trunk/gui/video2.cpp

    r265 r269  
    7575#include <avcode.h>
    7676
    77     int dvd_chapter_from_cell(dvd_priv_t* dvd,int title,int cell);
    78 
    79     HMTX demux_mtx;
    80     HMTX dart_cb_mtx;
    81     static float prevTime = 0;
    82     extern int index_mode;
    83     extern struct ReferenceList *Refer;
    84     extern audio_header_t audio_header;
    85     extern video_header_t video_header;
    86     float audio_delay = 0;
    87     BOOL debug=0;
     77}  // extern C
     78
     79HMTX demux_mtx;
     80HMTX dart_cb_mtx;
     81static float prevTime = 0;
     82extern int index_mode;
     83extern struct ReferenceList *Refer;
     84extern audio_header_t audio_header;
     85extern video_header_t video_header;
     86float audio_delay = 0;
     87BOOL debug=0;
    8888//    extern void *dvdcss_library;
    89     extern HMODULE CSSHandle;
    90 
    91 #define DART_MAX_WAIT 10000L // 10 sec
    92 
    93     /*
    94      int snprintf (char *a, size_t b, const char *format, ...)
    95      {
    96      va_list arg_ptr;
    97 
    98      va_start(arg_ptr, format);
    99      vsprintf(a, format, arg_ptr);
    100      va_end(arg_ptr);
    101 
    102      return 0;
    103      }
    104      */
    105 
    106     static unsigned char KeyTitle[128];
    107     static unsigned char KeyPhrase[128];
    108     static unsigned char KeyTemp[128];
    109     char RegTo[128];
    110 
    111     char keyFileName[255]= {0};
    112     BOOL keyReaded = FALSE;
    113     int KeyPreRead(void)
     89extern HMODULE CSSHandle;
     90
     91extern "C" void dprintf(const char *fmt,...);
     92FILE *wv_log = 0;
     93void dprintf(const char *fmt,...)
     94{
     95    va_list arg_ptr;
     96    if (debug)
    11497    {
    115         int krc;
    116         ULONG action;
    117         HFILE keyFile=0;
    118         //    unsigned char keyFileName[]="wvgui.reg";
    119 
    120         krc=DosOpen((PCSZ)keyFileName,
    121                     &keyFile,
    122                     &action,
    123                     0,
    124                     0,
    125                     OPEN_ACTION_OPEN_IF_EXISTS,
    126                     OPEN_SHARE_DENYREADWRITE|OPEN_ACCESS_READONLY,
    127                     0);
    128 
    129         if (krc) return FALSE;
    130 
    131         krc=DosRead(keyFile,KeyTitle,128,&action);
    132         if (krc) return FALSE;
    133         krc=DosRead(keyFile,KeyPhrase,128,&action);
    134         if (krc) return FALSE;
    135 
    136         krc=DosClose(keyFile);
    137 
    138         return TRUE;
    139 
     98        va_start(arg_ptr, fmt);
     99        vfprintf(wv_log, fmt, arg_ptr);
     100        fflush(wv_log);
     101        va_end(arg_ptr);
    140102    }
    141 
    142     static R_RSA_PUBLIC_KEY PUBLIC_KEY1 = {
    143         1024,
    144         {
    145             0xb5, 0x4c, 0xbf, 0xeb, 0x48, 0x70, 0x7a, 0xff,
    146             0xc3, 0xe1, 0x15, 0xa7, 0x1e, 0xa3, 0xc1, 0x5a,
    147             0xd6, 0x90, 0x9a, 0xf0, 0xec, 0x0f, 0x48, 0xc3,
    148             0x94, 0xf7, 0xe3, 0x55, 0x18, 0x28, 0x81, 0x73,
    149             0xec, 0xe0, 0xdd, 0x37, 0x43, 0x20, 0x05, 0x0b,
    150             0xf4, 0x5a, 0xfb, 0x2e, 0x13, 0xa7, 0x14, 0x2f,
    151             0x0c, 0x09, 0xc1, 0x20, 0x9b, 0xa4, 0x3d, 0xb2,
    152             0x84, 0xc4, 0x59, 0xf2, 0x3c, 0x7c, 0x6f, 0x52,
    153             0x3e, 0x13, 0x39, 0x23, 0x59, 0x72, 0x48, 0xca,
    154             0x2a, 0x8a, 0xaf, 0xdd, 0x77, 0x9c, 0x94, 0x41,
    155             0x19, 0xa6, 0x71, 0x2f, 0x29, 0x30, 0x6f, 0x83,
    156             0x41, 0x1a, 0xf4, 0x67, 0xe0, 0x49, 0x42, 0x8d,
    157             0xac, 0x66, 0x4f, 0xb6, 0x1a, 0x93, 0x4a, 0x41,
    158             0x85, 0x98, 0x69, 0x0b, 0x0d, 0x6f, 0x45, 0xb2,
    159             0xd7, 0xc9, 0x4c, 0xf2, 0xe5, 0x58, 0xde, 0xbb,
    160             0x6e, 0xbf, 0xbf, 0x9d, 0xab, 0xa1, 0x17, 0xf7
    161         },
    162         {
    163             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    164             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    165             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    166             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    167             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    168             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    169             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    170             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    171             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    172             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    173             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    174             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    175             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    176             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    177             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    178             0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01
    179         }
    180     };
    181 
    182     FILE *wv_log = 0;
    183 
    184     void dprintf(const char *fmt,...)
    185     {
    186 
    187         va_list arg_ptr;
    188 
    189         if (debug)
    190         {
    191             va_start(arg_ptr, fmt);
    192             vfprintf(wv_log, fmt, arg_ptr);
    193             fflush(wv_log);
    194             va_end(arg_ptr);
    195         }
    196 //        DosSleep(1);
    197         return;
    198     }
    199 
    200 
    201 }  // extern C
     103    return;
     104}
     105
     106BOOL keyReaded = FALSE;
     107int KeyPreRead(void)
     108{
     109    return TRUE;
     110}
    202111
    203112t_VOutCaps *VOutCaps = NULL; /* Video out plugin caps */
    … …  
    375284void  PlayAllPlaylist(void *arg)
    376285{
    377    
     286
    378287    pplayItem *pFirst = (pplayItem*)arg;
    379288    pplayItem pp;
    … …  
    445354BOOL IsRegistered(void) // check is copy is registered?
    446355{
    447     unsigned int klen;
    448     //static unsigned char KeyTitle[128];
    449     //static unsigned char KeyPhrase[128];
    450     //static unsigned char KeyTemp[128];
    451     klen = sizeof(KeyTitle);
    452     memset(RegTo,0,sizeof(RegTo));
    453     strcpy(RegTo, "Unregistred");
    454     if (keyReaded)
    455     {
    456         memset(KeyTemp,0,klen);
    457         RSAPublicDecrypt(KeyTemp,&klen,KeyPhrase,128,&PUBLIC_KEY1);
    458         if (strcmp((char*)KeyTemp,(char*)KeyTitle) == 0)
    459         {
    460             memset(RegTo,0,sizeof(RegTo));
    461             strcpy(RegTo,(char*)KeyTemp+12);
    462             return TRUE;
    463         }
    464         else return FALSE;
    465     }
    466     else return FALSE;
     356    return TRUE;
    467357}
    468358
    … …  
    594484
    595485    strcpy(prog_path,full_ini);
    596     strcpy(keyFileName,full_ini);
    597486    strcat(full_ini,"VIDEO2.INI");
    598     strcat(keyFileName,"WVGUI.REG");
    599487    // Try morphing into a PM application.
    600488#ifndef PMAPI
    … …  
    625513        sprintf(cpto,"IBM-%d\0",aulCpList[0]);
    626514
    627     printf ("Current codepage: %u (%s)\n", aulCpList[0],cpto);fflush(stdout);
     515    printf("Current codepage: %u (%s)\n", aulCpList[0],cpto);fflush(stdout);
    628516
    629517    hab = WinInitialize (0);
    … …  
    778666
    779667    reg=IsRegistered();
    780     dprintf("Registered copy to: %s\n",RegTo);
     668    dprintf("Registered copy to: %s\n","OSS");
    781669    dprintf("Built: %s\n",VERSION);
    782670    printf("Built: %s\n",VERSION);

  • TabularUnified trunk/gui/video2.hpp

    r265 r269  
    166166#define TIMER_NOHIRES 1
    167167#define TIMER_HIRES   2
     168
     169#define DART_MAX_WAIT 5000
    168170// ===================================================
    169 // ƒ«®¡ «ì­ë¥ ¯¥à¥¬¥­­ë¥
     171// Global variables
    170172// ===================================================
    171173
    … …  
    670672extern HWND hwndList;
    671673int subcc_enabled;
    672 spudec_handle_t *spudec;
     674void *spudec;
    673675static void draw_alpha(int x0, int y0, int w, int h, unsigned char *src, unsigned char *srca, int stride);
    674676BOOL loadZLib( void );

  • TabularUnified trunk/gui/wvguidlg.cpp

    r265 r269  
    327327extern int pp_quality;
    328328extern int no_video;
    329 extern char RegTo[128];
    330329extern char cpfrom[10];
    331330extern char TVINChannelName[40];
    … …  
    13951394    {
    13961395    case WM_INITDLG:
    1397         sprintf(buf, "Registered to: %s",RegTo);
     1396        sprintf(buf, "Registered to: %s","OSS");
    13981397        WinSetDlgItemText(hwnd,IDD_REGISTRATION,
    13991398                          (const unsigned char*)buf);

  • TabularUnified trunk/libavcodec/Makefile

    r261 r269  
    11!include ..\Makefile.inc
    22
    3 INCL   = -I. -I.. -I..\libavutil -I..\libfaad -I..\libswscale
     3INCL   = -I. -I.. -I..\libavutil -I..\libfaad -I..\libswscale -I..\zlib
    44CFLAGS = $(CFLAGS) -DHAVE_AV_CONFIG_H -DUSE_FASTMEMCPY
    55
    … …  
    77       mpegvideo.obj jrevdct.obj jfdctfst.obj jfdctint.obj \
    88       mpegaudio.obj mjpeg.obj resample.obj dsputil.obj \
    9        motion_est.obj imgconvert.obj imgresample.obj raw.obj \
     9       motion_est.obj imgconvert.obj raw.obj \
    1010       mpeg12.obj mpegaudiodec.obj pcm.obj simple_idct.obj \
    1111       ratecontrol.obj adpcm.obj eval.obj dv.obj error_resilience.obj \
    … …  
    1414       h264.obj golomb.obj indeo3.obj vp3.obj asv1.obj 4xm.obj cabac.obj \
    1515       ffv1.obj ra144.obj ra288.obj ac3enc.obj vcr1.obj cljr.obj \
    16        roqvideo.obj dpcm.obj interplayvideo.obj xan.obj faad.obj
     16       roqvideo.obj dpcm.obj interplayvideo.obj xan.obj faad.obj \
     17       truespeech.obj dvdsubenc.obj cscd.obj nuv.obj avs.obj cavs.obj \
     18       vorbis_enc.obj fraps.obj wavpack.obj rtjpeg.obj bmp.obj tiertexseqv.obj \
     19       smacker.obj imc.obj vmnc.obj tiff.obj flashsv.obj gifdec.obj mmvideo.obj
     20
    1721
    1822OBJS2 = rpza.obj cinepak.obj msrle.obj msvideo1.obj vqavideo.obj idcinvideo.obj \
    … …  
    2529       dvbsubdec.obj qdm2.obj truemotion2.obj cook.obj amr.obj vorbis.obj tta.obj \
    2630       kmvc.obj cavs.obj bitstream_filter.obj vc1dsp.obj vp6.obj vp56.obj \
    27        vp56data.obj vp5.obj vorbis_data.obj targa.obj dsicinav.obj
     31       vp56data.obj vp5.obj vorbis_data.obj targa.obj dsicinav.obj gif.obj \
     32       flacenc.obj zmbv.obj lzo.obj lzw.obj cavsdsp.obj
    2833
    2934OBJS1 = libpostproc/postprocess.obj \
    … …  
    3237       i386/idct_mmx.obj i386/motion_est_mmx.obj i386/vp3dsp_sse2.obj \
    3338       i386/simple_idct_mmx.obj i386/fft_sse.obj i386/vp3dsp_mmx.obj \
    34        i386/fft_3dn2.obj i386/fft_3dn.obj \
     39       i386/fft_3dn2.obj i386/fft_3dn.obj i386/cavsdsp_mmx.obj \
    3540       fasmemcpy/fast_memcpy.obj fasmemcpy/fastmemcpy.obj os2thread.obj
    3641
    … …  
    4146$(LIB): $(OBJS) $(OBJS1) $(OBJS2)
    4247        -del *.lib
    43         emxomfar -p128 r $@ $(OBJS)
    44         emxomfar -p128 r $@ $(OBJS1)
    45         emxomfar -p128 r $@ $(OBJS2)
     48        emxomfar -p256 r $@ $(OBJS)
     49        emxomfar -p256 r $@ $(OBJS1)
     50        emxomfar -p256 r $@ $(OBJS2)
    4651
    4752.c.obj:

  • TabularUnified trunk/libavcodec/ac3enc.c

    r256 r269  
    13801380            if (v < 0)
    13811381                v = 0;
    1382             exp_samples[i][ch] = v - 9;
     1382            exp_samples[i][ch] = v - 10;
    13831383            lshift_tab(input_samples, N, v);
    13841384

  • TabularUnified trunk/libavcodec/alac.c

    r256 r269  
    473473            return input_buffer_size;
    474474        }
    475         alac_set_info(alac);
     475        if (alac_set_info(alac)) {
     476            av_log(avctx, AV_LOG_ERROR, "alac: set_info failed\n");
     477            return input_buffer_size;
     478        }
    476479        alac->context_initialized = 1;
    477480    }

  • TabularUnified trunk/libavcodec/allcodecs.c

    r263 r269  
    2626
    2727#include "avcodec.h"
     28
     29#define REGISTER_ENCODER(X,x) \
     30          if(ENABLE_##X##_ENCODER)  register_avcodec(&x##_encoder)
     31#define REGISTER_DECODER(X,x) \
     32          if(ENABLE_##X##_DECODER)  register_avcodec(&x##_decoder)
     33#define REGISTER_ENCDEC(X,x)  REGISTER_ENCODER(X,x); REGISTER_DECODER(X,x)
     34
     35#define REGISTER_PARSER(X,x) \
     36          if(ENABLE_##X##_PARSER)  av_register_codec_parser(&x##_parser)
    2837
    2938/* If you do not call this function, then you can select exactly which
    … …  
    4150    inited = 1;
    4251
    43     /* encoders */
    44 #ifdef CONFIG_AC3_ENCODER
    45     register_avcodec(&ac3_encoder);
    46 #endif //CONFIG_AC3_ENCODER
    47 #ifdef CONFIG_MP2_ENCODER
    48     register_avcodec(&mp2_encoder);
    49 #endif //CONFIG_MP2_ENCODER
     52    /* video codecs */
     53    REGISTER_DECODER(AASC, aasc);
     54    REGISTER_ENCDEC (ASV1, asv1);
     55    REGISTER_ENCDEC (ASV2, asv2);
     56    REGISTER_DECODER(AVS, avs);
     57    REGISTER_DECODER(BMP, bmp);
     58    REGISTER_DECODER(CAVS, cavs);
     59    REGISTER_DECODER(CINEPAK, cinepak);
     60    REGISTER_DECODER(CLJR, cljr);
     61    REGISTER_DECODER(CSCD, cscd);
     62    REGISTER_DECODER(CYUV, cyuv);
     63    REGISTER_DECODER(DSICINVIDEO, dsicinvideo);
     64    REGISTER_ENCDEC (DVVIDEO, dvvideo);
     65    REGISTER_DECODER(EIGHTBPS, eightbps);
     66    REGISTER_ENCDEC (FFV1, ffv1);
     67    REGISTER_ENCDEC (FFVHUFF, ffvhuff);
     68    REGISTER_DECODER(FLASHSV, flashsv);
     69    REGISTER_DECODER(FLIC, flic);
     70    REGISTER_ENCDEC (FLV, flv);
     71    REGISTER_DECODER(FOURXM, fourxm);
     72    REGISTER_DECODER(FRAPS, fraps);
     73    REGISTER_ENCDEC (GIF, gif);
     74    REGISTER_ENCDEC (H261, h261);
     75    REGISTER_ENCDEC (H263, h263);
     76    REGISTER_DECODER(H263I, h263i);
     77    REGISTER_ENCODER(H263P, h263p);
     78    REGISTER_DECODER(H264, h264);
     79    REGISTER_ENCDEC (HUFFYUV, huffyuv);
     80    REGISTER_DECODER(IDCIN, idcin);
     81    REGISTER_DECODER(INDEO2, indeo2);
     82    REGISTER_DECODER(INDEO3, indeo3);
     83    REGISTER_DECODER(INTERPLAY_VIDEO, interplay_video);
     84    REGISTER_ENCODER(JPEGLS, jpegls);
     85    REGISTER_DECODER(KMVC, kmvc);
     86    REGISTER_ENCODER(LJPEG, ljpeg);
     87    REGISTER_DECODER(LOCO, loco);
     88    REGISTER_DECODER(MDEC, mdec);
     89    REGISTER_ENCDEC (MJPEG, mjpeg);
     90    REGISTER_DECODER(MJPEGB, mjpegb);
     91    REGISTER_DECODER(MMVIDEO, mmvideo);
     92#ifdef HAVE_XVMC
     93    REGISTER_DECODER(MPEG_XVMC, mpeg_xvmc);
     94#endif
     95    REGISTER_ENCDEC (MPEG1VIDEO, mpeg1video);
     96    REGISTER_ENCDEC (MPEG2VIDEO, mpeg2video);
     97    REGISTER_ENCDEC (MPEG4, mpeg4);
     98    REGISTER_DECODER(MPEGVIDEO, mpegvideo);
     99    REGISTER_ENCDEC (MSMPEG4V1, msmpeg4v1);
     100    REGISTER_ENCDEC (MSMPEG4V2, msmpeg4v2);
     101    REGISTER_ENCDEC (MSMPEG4V3, msmpeg4v3);
     102    REGISTER_DECODER(MSRLE, msrle);
     103    REGISTER_DECODER(MSVIDEO1, msvideo1);
     104    REGISTER_DECODER(MSZH, mszh);
     105    REGISTER_DECODER(NUV, nuv);
     106    REGISTER_ENCODER(PAM, pam);
     107    REGISTER_ENCODER(PBM, pbm);
     108    REGISTER_ENCODER(PGM, pgm);
     109    REGISTER_ENCODER(PGMYUV, pgmyuv);
     110#ifdef CONFIG_ZLIB
     111    REGISTER_ENCDEC (PNG, png);
     112#endif
     113    REGISTER_ENCODER(PPM, ppm);
     114    REGISTER_DECODER(QDRAW, qdraw);
     115    REGISTER_DECODER(QPEG, qpeg);
     116    REGISTER_DECODER(QTRLE, qtrle);
     117    REGISTER_ENCDEC (RAWVIDEO, rawvideo);
     118    REGISTER_DECODER(ROQ, roq);
     119    REGISTER_DECODER(RPZA, rpza);
     120    REGISTER_ENCDEC (RV10, rv10);
     121    REGISTER_ENCDEC (RV20, rv20);
     122    REGISTER_DECODER(SMACKER, smacker);
     123    REGISTER_DECODER(SMC, smc);
     124    REGISTER_ENCDEC (SNOW, snow);
     125    REGISTER_DECODER(SP5X, sp5x);
     126    REGISTER_ENCDEC (SVQ1, svq1);
     127    REGISTER_DECODER(SVQ3, svq3);
     128    REGISTER_DECODER(TARGA, targa);
     129    REGISTER_DECODER(THEORA, theora);
     130    REGISTER_DECODER(TIERTEXSEQVIDEO, tiertexseqvideo);
     131    REGISTER_DECODER(TIFF, tiff);
     132    REGISTER_DECODER(TRUEMOTION1, truemotion1);
     133    REGISTER_DECODER(TRUEMOTION2, truemotion2);
     134    REGISTER_DECODER(TSCC, tscc);
     135    REGISTER_DECODER(ULTI, ulti);
     136    REGISTER_DECODER(VC1, vc1);
     137    REGISTER_DECODER(VCR1, vcr1);
     138    REGISTER_DECODER(VMDVIDEO, vmdvideo);
     139    REGISTER_DECODER(VMNC, vmnc);
     140    REGISTER_DECODER(VP3, vp3);
     141    REGISTER_DECODER(VP5, vp5);
     142    REGISTER_DECODER(VP6, vp6);
     143    REGISTER_DECODER(VP6F, vp6f);
     144    REGISTER_DECODER(VQA, vqa);
     145    REGISTER_ENCDEC (WMV1, wmv1);
     146    REGISTER_ENCDEC (WMV2, wmv2);
     147    REGISTER_DECODER(WMV3, wmv3);
     148    REGISTER_DECODER(WNV1, wnv1);
     149#ifdef CONFIG_X264
     150    REGISTER_ENCODER(X264, x264);
     151#endif
     152    REGISTER_DECODER(XAN_WC3, xan_wc3);
     153    REGISTER_DECODER(XL, xl);
     154#ifdef CONFIG_XVID
     155    REGISTER_ENCODER(XVID, xvid);
     156#endif
     157    REGISTER_ENCDEC (ZLIB, zlib);
     158    REGISTER_DECODER(ZMBV, zmbv);
     159
     160    /* audio codecs */
     161#ifdef CONFIG_FAAD
     162    REGISTER_DECODER(AAC, aac);
     163    REGISTER_DECODER(MPEG4AAC, mpeg4aac);
     164#endif
     165#ifdef CONFIG_A52
     166    REGISTER_DECODER(AC3, ac3);
     167#endif
     168    REGISTER_ENCODER(AC3, ac3);
     169    REGISTER_DECODER(ALAC, alac);
     170#if defined(CONFIG_AMR_NB) || defined(CONFIG_AMR_NB_FIXED)
     171    REGISTER_ENCDEC (AMR_NB, amr_nb);
     172#endif
     173#ifdef CONFIG_AMR_WB
     174    REGISTER_ENCDEC (AMR_WB, amr_wb);
     175#endif
     176    REGISTER_DECODER(COOK, cook);
     177    REGISTER_DECODER(DSICINAUDIO, dsicinaudio);
     178#ifdef CONFIG_DTS
     179    REGISTER_DECODER(DTS, dts);
     180#endif
     181#ifdef CONFIG_FAAC
     182    REGISTER_ENCODER(FAAC, faac);
     183#endif
     184    REGISTER_ENCDEC (FLAC, flac);
     185    REGISTER_DECODER(IMC, imc);
     186#ifdef CONFIG_LIBGSM
     187    REGISTER_ENCDEC (LIBGSM, libgsm);
     188#endif
     189    REGISTER_DECODER(MACE3, mace3);
     190    REGISTER_DECODER(MACE6, mace6);
     191    REGISTER_ENCDEC (MP2, mp2);
     192    REGISTER_DECODER(MP3, mp3);
     193    REGISTER_DECODER(MP3ADU, mp3adu);
    50194#ifdef CONFIG_MP3LAME
    51 #ifdef CONFIG_MP3LAME_ENCODER
    52     register_avcodec(&mp3lame_encoder);
    53 #endif //CONFIG_MP3LAME_ENCODER
    54 #endif
     195    REGISTER_ENCODER(MP3LAME, mp3lame);
     196#endif
     197    REGISTER_DECODER(MP3ON4, mp3on4);
    55198#ifdef CONFIG_LIBVORBIS
    56 #if (defined CONFIG_OGGVORBIS_ENCODER && !defined CONFIG_VORBIS_ENCODER)
    57     register_avcodec(&oggvorbis_encoder);
    58 #endif //CONFIG_OGGVORBIS_ENCODER
    59 #if (defined CONFIG_OGGVORBIS_DECODER && !defined CONFIG_VORBIS_DECODER)
    60     register_avcodec(&oggvorbis_decoder);
    61 #endif //CONFIG_OGGVORBIS_DECODER
    62 #endif
    63 #ifdef CONFIG_FAAC
    64 #ifdef CONFIG_FAAC_ENCODER
    65     register_avcodec(&faac_encoder);
    66 #endif //CONFIG_FAAC_ENCODER
    67 #endif
    68 #ifdef CONFIG_FLAC_ENCODER
    69     register_avcodec(&flac_encoder);
    70 #endif
    71 #ifdef CONFIG_GIF_ENCODER
    72     register_avcodec(&gif_encoder);
    73 #endif
    74 #ifdef CONFIG_XVID
    75 #ifdef CONFIG_XVID_ENCODER
    76     register_avcodec(&xvid_encoder);
    77 #endif //CONFIG_XVID_ENCODER
    78 #endif
    79 #ifdef CONFIG_MPEG1VIDEO_ENCODER
    80     register_avcodec(&mpeg1video_encoder);
    81 #endif //CONFIG_MPEG1VIDEO_ENCODER
    82 #ifdef CONFIG_H264_ENCODER
    83 //    register_avcodec(&h264_encoder);
    84 #endif //CONFIG_H264_ENCODER
    85 #ifdef CONFIG_MPEG2VIDEO_ENCODER
    86     register_avcodec(&mpeg2video_encoder);
    87 #endif //CONFIG_MPEG2VIDEO_ENCODER
    88 #ifdef CONFIG_H261_ENCODER
    89     register_avcodec(&h261_encoder);
    90 #endif //CONFIG_H261_ENCODER
    91 #ifdef CONFIG_H263_ENCODER
    92     register_avcodec(&h263_encoder);
    93 #endif //CONFIG_H263_ENCODER
    94 #ifdef CONFIG_H263P_ENCODER
    95     register_avcodec(&h263p_encoder);
    96 #endif //CONFIG_H263P_ENCODER
    97 #ifdef CONFIG_FLV_ENCODER
    98     register_avcodec(&flv_encoder);
    99 #endif //CONFIG_FLV_ENCODER
    100 #ifdef CONFIG_RV10_ENCODER
    101     register_avcodec(&rv10_encoder);
    102 #endif //CONFIG_RV10_ENCODER
    103 #ifdef CONFIG_RV20_ENCODER
    104     register_avcodec(&rv20_encoder);
    105 #endif //CONFIG_RV20_ENCODER
    106 #ifdef CONFIG_MPEG4_ENCODER
    107     register_avcodec(&mpeg4_encoder);
    108 #endif //CONFIG_MPEG4_ENCODER
    109 #ifdef CONFIG_MSMPEG4V1_ENCODER
    110     register_avcodec(&msmpeg4v1_encoder);
    111 #endif //CONFIG_MSMPEG4V1_ENCODER
    112 #ifdef CONFIG_MSMPEG4V2_ENCODER
    113     register_avcodec(&msmpeg4v2_encoder);
    114 #endif //CONFIG_MSMPEG4V2_ENCODER
    115 #ifdef CONFIG_MSMPEG4V3_ENCODER
    116     register_avcodec(&msmpeg4v3_encoder);
    117 #endif //CONFIG_MSMPEG4V3_ENCODER
    118 #ifdef CONFIG_WMV1_ENCODER
    119     register_avcodec(&wmv1_encoder);
    120 #endif //CONFIG_WMV1_ENCODER
    121 #ifdef CONFIG_WMV2_ENCODER
    122     register_avcodec(&wmv2_encoder);
    123 #endif //CONFIG_WMV2_ENCODER
    124 #ifdef CONFIG_SVQ1_ENCODER
    125     register_avcodec(&svq1_encoder);
    126 #endif //CONFIG_SVQ1_ENCODER
    127 #ifdef CONFIG_MJPEG_ENCODER
    128     register_avcodec(&mjpeg_encoder);
    129 #endif //CONFIG_MJPEG_ENCODER
    130 #ifdef CONFIG_LJPEG_ENCODER
    131     register_avcodec(&ljpeg_encoder);
    132 #endif //CONFIG_LJPEG_ENCODER
    133 #ifdef CONFIG_JPEGLS_ENCODER
    134     register_avcodec(&jpegls_encoder);
    135 #endif //CONFIG_JPEGLS_ENCODER
    136 #ifdef CONFIG_ZLIB
    137 #ifdef CONFIG_PNG_ENCODER
    138     register_avcodec(&png_encoder);
    139 #endif //CONFIG_PNG_ENCODER
    140 #endif
    141 #ifdef CONFIG_PPM_ENCODER
    142     register_avcodec(&ppm_encoder);
    143 #endif //CONFIG_PPM_ENCODER
    144 #ifdef CONFIG_PGM_ENCODER
    145     register_avcodec(&pgm_encoder);
    146 #endif //CONFIG_PGM_ENCODER
    147 #ifdef CONFIG_PGMYUV_ENCODER
    148     register_avcodec(&pgmyuv_encoder);
    149 #endif //CONFIG_PGMYUV_ENCODER
    150 #ifdef CONFIG_PBM_ENCODER
    151     register_avcodec(&pbm_encoder);
    152 #endif //CONFIG_PBM_ENCODER
    153 #ifdef CONFIG_PAM_ENCODER
    154     register_avcodec(&pam_encoder);
    155 #endif //CONFIG_PAM_ENCODER
    156 #ifdef CONFIG_HUFFYUV_ENCODER
    157     register_avcodec(&huffyuv_encoder);
    158 #endif //CONFIG_HUFFYUV_ENCODER
    159 #ifdef CONFIG_FFVHUFF_ENCODER
    160     register_avcodec(&ffvhuff_encoder);
    161 #endif //CONFIG_FFVHUFF_ENCODER
    162 #ifdef CONFIG_ASV1_ENCODER
    163     register_avcodec(&asv1_encoder);
    164 #endif //CONFIG_ASV1_ENCODER
    165 #ifdef CONFIG_ASV2_ENCODER
    166     register_avcodec(&asv2_encoder);
    167 #endif //CONFIG_ASV2_ENCODER
    168 #ifdef CONFIG_FFV1_ENCODER
    169     register_avcodec(&ffv1_encoder);
    170 #endif //CONFIG_FFV1_ENCODER
    171 #ifdef CONFIG_SNOW_ENCODER
    172     register_avcodec(&snow_encoder);
    173 #endif //CONFIG_SNOW_ENCODER
    174 #ifdef CONFIG_ZLIB_ENCODER
    175     register_avcodec(&zlib_encoder);
    176 #endif //CONFIG_ZLIB_ENCODER
    177 #ifdef CONFIG_DVVIDEO_ENCODER
    178     register_avcodec(&dvvideo_encoder);
    179 #endif //CONFIG_DVVIDEO_ENCODER
    180 #ifdef CONFIG_SONIC_ENCODER
    181     register_avcodec(&sonic_encoder);
    182 #endif //CONFIG_SONIC_ENCODER
    183 #ifdef CONFIG_SONIC_LS_ENCODER
    184     register_avcodec(&sonic_ls_encoder);
    185 #endif //CONFIG_SONIC_LS_ENCODER
    186 #ifdef CONFIG_X264
    187 #ifdef CONFIG_X264_ENCODER
    188     register_avcodec(&x264_encoder);
    189 #endif //CONFIG_X264_ENCODER
    190 #endif
    191 #ifdef CONFIG_LIBGSM
    192     register_avcodec(&libgsm_encoder);
    193 #endif //CONFIG_LIBGSM
    194 #ifdef CONFIG_RAWVIDEO_ENCODER
    195     register_avcodec(&rawvideo_encoder);
    196 #endif //CONFIG_RAWVIDEO_ENCODER
    197 
    198     /* decoders */
    199 #ifdef CONFIG_GIF_DECODER
    200     register_avcodec(&gif_decoder);
    201 #endif
    202 #ifdef CONFIG_H263_DECODER
    203     register_avcodec(&h263_decoder);
    204 #endif //CONFIG_H263_DECODER
    205 #ifdef CONFIG_H261_DECODER
    206     register_avcodec(&h261_decoder);
    207 #endif //CONFIG_H261_DECODER
    208 #ifdef CONFIG_MPEG4_DECODER
    209     register_avcodec(&mpeg4_decoder);
    210 #endif //CONFIG_MPEG4_DECODER
    211 #ifdef CONFIG_MSMPEG4V1_DECODER
    212     register_avcodec(&msmpeg4v1_decoder);
    213 #endif //CONFIG_MSMPEG4V1_DECODER
    214 #ifdef CONFIG_MSMPEG4V2_DECODER
    215     register_avcodec(&msmpeg4v2_decoder);
    216 #endif //CONFIG_MSMPEG4V2_DECODER
    217 #ifdef CONFIG_MSMPEG4V3_DECODER
    218     register_avcodec(&msmpeg4v3_decoder);
    219 #endif //CONFIG_MSMPEG4V3_DECODER
    220 #ifdef CONFIG_WMV1_DECODER
    221     register_avcodec(&wmv1_decoder);
    222 #endif //CONFIG_WMV1_DECODER
    223 #ifdef CONFIG_WMV2_DECODER
    224     register_avcodec(&wmv2_decoder);
    225 #endif //CONFIG_WMV2_DECODER
    226 #ifdef CONFIG_VC1_DECODER
    227     register_avcodec(&vc1_decoder);
    228 #endif //CONFIG_VC1_DECODER
    229 #ifdef CONFIG_WMV3_DECODER
    230     register_avcodec(&wmv3_decoder);
    231 #endif //CONFIG_WMV3_DECODER
    232 #ifdef CONFIG_H263I_DECODER
    233     register_avcodec(&h263i_decoder);
    234 #endif //CONFIG_H263I_DECODER
    235 #ifdef CONFIG_FLV_DECODER
    236     register_avcodec(&flv_decoder);
    237 #endif //CONFIG_FLV_DECODER
    238 #ifdef CONFIG_RV10_DECODER
    239     register_avcodec(&rv10_decoder);
    240 #endif //CONFIG_RV10_DECODER
    241 #ifdef CONFIG_RV20_DECODER
    242     register_avcodec(&rv20_decoder);
    243 #endif //CONFIG_RV20_DECODER
    244 #ifdef CONFIG_SVQ1_DECODER
    245     register_avcodec(&svq1_decoder);
    246 #endif //CONFIG_SVQ1_DECODER
    247 #ifdef CONFIG_SVQ3_DECODER
    248     register_avcodec(&svq3_decoder);
    249 #endif //CONFIG_SVQ3_DECODER
    250 #ifdef CONFIG_WMAV1_DECODER
    251     register_avcodec(&wmav1_decoder);
    252 #endif //CONFIG_WMAV1_DECODER
    253 #ifdef CONFIG_WMAV2_DECODER
    254     register_avcodec(&wmav2_decoder);
    255 #endif //CONFIG_WMAV2_DECODER
    256 #ifdef CONFIG_INDEO2_DECODER
    257     register_avcodec(&indeo2_decoder);
    258 #endif //CONFIG_INDEO2_DECODER
    259 #ifdef CONFIG_INDEO3_DECODER
    260     register_avcodec(&indeo3_decoder);
    261 #endif //CONFIG_INDEO3_DECODER
    262 #ifdef CONFIG_TSCC_DECODER
    263     register_avcodec(&tscc_decoder);
    264 #endif //CONFIG_TSCC_DECODER
    265 #ifdef CONFIG_CSCD_DECODER
    266     register_avcodec(&cscd_decoder);
    267 #endif //CONFIG_CSCD_DECODER
    268 #ifdef CONFIG_NUV_DECODER
    269     register_avcodec(&nuv_decoder);
    270 #endif //CONFIG_NUV_DECODER
    271 #ifdef CONFIG_ULTI_DECODER
    272     register_avcodec(&ulti_decoder);
    273 #endif //CONFIG_ULTI_DECODER
    274 #ifdef CONFIG_QDRAW_DECODER
    275     register_avcodec(&qdraw_decoder);
    276 #endif //CONFIG_QDRAW_DECODER
    277 #ifdef CONFIG_XL_DECODER
    278     register_avcodec(&xl_decoder);
    279 #endif //CONFIG_XL_DECODER
    280 #ifdef CONFIG_QPEG_DECODER
    281     register_avcodec(&qpeg_decoder);
    282 #endif //CONFIG_QPEG_DECODER
    283 #ifdef CONFIG_LOCO_DECODER
    284     register_avcodec(&loco_decoder);
    285 #endif //CONFIG_LOCO_DECODER
    286 #ifdef CONFIG_KMVC_DECODER
    287     register_avcodec(&kmvc_decoder);
    288 #endif //CONFIG_KMVC_DECODER
    289 #ifdef CONFIG_WNV1_DECODER
    290     register_avcodec(&wnv1_decoder);
    291 #endif //CONFIG_WNV1_DECODER
    292 #ifdef CONFIG_AASC_DECODER
    293     register_avcodec(&aasc_decoder);
    294 #endif //CONFIG_AASC_DECODER
    295 #ifdef CONFIG_FRAPS_DECODER
    296     register_avcodec(&fraps_decoder);
    297 #endif //CONFIG_FRAPS_DECODER
    298 #ifdef CONFIG_FAAD
    299 #ifdef CONFIG_AAC_DECODER
    300     register_avcodec(&aac_decoder);
    301 #endif //CONFIG_AAC_DECODER
    302 #ifdef CONFIG_MPEG4AAC_DECODER
    303     register_avcodec(&mpeg4aac_decoder);
    304 #endif //CONFIG_MPEG4AAC_DECODER
    305 #endif
    306 #ifdef CONFIG_MPEG1VIDEO_DECODER
    307     register_avcodec(&mpeg1video_decoder);
    308 #endif //CONFIG_MPEG1VIDEO_DECODER
    309 #ifdef CONFIG_MPEG2VIDEO_DECODER
    310     register_avcodec(&mpeg2video_decoder);
    311 #endif //CONFIG_MPEG2VIDEO_DECODER
    312 #ifdef CONFIG_MPEGVIDEO_DECODER
    313     register_avcodec(&mpegvideo_decoder);
    314 #endif //CONFIG_MPEGVIDEO_DECODER
    315 #ifdef HAVE_XVMC
    316 #ifdef CONFIG_MPEG_XVMC_DECODER
    317     register_avcodec(&mpeg_xvmc_decoder);
    318 #endif //CONFIG_MPEG_XVMC_DECODER
    319 #endif
    320 #ifdef CONFIG_DVVIDEO_DECODER
    321     register_avcodec(&dvvideo_decoder);
    322 #endif //CONFIG_DVVIDEO_DECODER
    323 #ifdef CONFIG_MJPEG_DECODER
    324     register_avcodec(&mjpeg_decoder);
    325 #endif //CONFIG_MJPEG_DECODER
    326 #ifdef CONFIG_MJPEGB_DECODER
    327     register_avcodec(&mjpegb_decoder);
    328 #endif //CONFIG_MJPEGB_DECODER
    329 #ifdef CONFIG_SP5X_DECODER
    330     register_avcodec(&sp5x_decoder);
    331 #endif //CONFIG_SP5X_DECODER
    332 #ifdef CONFIG_ZLIB
    333 #ifdef CONFIG_PNG_DECODER
    334     register_avcodec(&png_decoder);
    335 #endif //CONFIG_PNG_DECODER
    336 #endif
    337 #ifdef CONFIG_MP2_DECODER
    338     register_avcodec(&mp2_decoder);
    339 #endif //CONFIG_MP2_DECODER
    340 #ifdef CONFIG_MP3_DECODER
    341     register_avcodec(&mp3_decoder);
    342 #endif //CONFIG_MP3_DECODER
    343 #ifdef CONFIG_MP3ADU_DECODER
    344     register_avcodec(&mp3adu_decoder);
    345 #endif //CONFIG_MP3ADU_DECODER
    346 #ifdef CONFIG_MP3ON4_DECODER
    347     register_avcodec(&mp3on4_decoder);
    348 #endif //CONFIG_MP3ON4_DECODER
    349 #ifdef CONFIG_MACE3_DECODER
    350     register_avcodec(&mace3_decoder);
    351 #endif //CONFIG_MACE3_DECODER
    352 #ifdef CONFIG_MACE6_DECODER
    353     register_avcodec(&mace6_decoder);
    354 #endif //CONFIG_MACE6_DECODER
    355 #ifdef CONFIG_HUFFYUV_DECODER
    356     register_avcodec(&huffyuv_decoder);
    357 #endif //CONFIG_HUFFYUV_DECODER
    358 #ifdef CONFIG_FFVHUFF_DECODER
    359     register_avcodec(&ffvhuff_decoder);
    360 #endif //CONFIG_FFVHUFF_DECODER
    361 #ifdef CONFIG_FFV1_DECODER
    362     register_avcodec(&ffv1_decoder);
    363 #endif //CONFIG_FFV1_DECODER
    364 #ifdef CONFIG_SNOW_DECODER
    365     register_avcodec(&snow_decoder);
    366 #endif //CONFIG_SNOW_DECODER
    367 #ifdef CONFIG_CYUV_DECODER
    368     register_avcodec(&cyuv_decoder);
    369 #endif //CONFIG_CYUV_DECODER
    370 #ifdef CONFIG_H264_DECODER
    371     register_avcodec(&h264_decoder);
    372 #endif //CONFIG_H264_DECODER
    373 #ifdef CONFIG_VP3_DECODER
    374     register_avcodec(&vp3_decoder);
    375 #endif //CONFIG_VP3_DECODER
    376 #ifdef CONFIG_THEORA_DECODER
    377     register_avcodec(&theora_decoder);
    378 #endif //CONFIG_THEORA_DECODER
    379 #ifdef CONFIG_VP5_DECODER
    380     register_avcodec(&vp5_decoder);
    381 #endif //CONFIG_VP5_DECODER
    382 #ifdef CONFIG_VP6_DECODER
    383     register_avcodec(&vp6_decoder);
    384 #endif //CONFIG_VP6_DECODER
    385 #ifdef CONFIG_VP6F_DECODER
    386     register_avcodec(&vp6f_decoder);
    387 #endif //CONFIG_VP6F_DECODER
    388 #ifdef CONFIG_ASV1_DECODER
    389     register_avcodec(&asv1_decoder);
    390 #endif //CONFIG_ASV1_DECODER
    391 #ifdef CONFIG_ASV2_DECODER
    392     register_avcodec(&asv2_decoder);
    393 #endif //CONFIG_ASV2_DECODER
    394 #ifdef CONFIG_VCR1_DECODER
    395     register_avcodec(&vcr1_decoder);
    396 #endif //CONFIG_VCR1_DECODER
    397 #ifdef CONFIG_CLJR_DECODER
    398     register_avcodec(&cljr_decoder);
    399 #endif //CONFIG_CLJR_DECODER
    400 #ifdef CONFIG_FOURXM_DECODER
    401     register_avcodec(&fourxm_decoder);
    402 #endif //CONFIG_FOURXM_DECODER
    403 #ifdef CONFIG_MDEC_DECODER
    404     register_avcodec(&mdec_decoder);
    405 #endif //CONFIG_MDEC_DECODER
    406 #ifdef CONFIG_ROQ_DECODER
    407     register_avcodec(&roq_decoder);
    408 #endif //CONFIG_ROQ_DECODER
    409 #ifdef CONFIG_INTERPLAY_VIDEO_DECODER
    410     register_avcodec(&interplay_video_decoder);
    411 #endif //CONFIG_INTERPLAY_VIDEO_DECODER
    412 #ifdef CONFIG_XAN_WC3_DECODER
    413     register_avcodec(&xan_wc3_decoder);
    414 #endif //CONFIG_XAN_WC3_DECODER
    415 #ifdef CONFIG_RPZA_DECODER
    416     register_avcodec(&rpza_decoder);
    417 #endif //CONFIG_RPZA_DECODER
    418 #ifdef CONFIG_CINEPAK_DECODER
    419     register_avcodec(&cinepak_decoder);
    420 #endif //CONFIG_CINEPAK_DECODER
    421 #ifdef CONFIG_MSRLE_DECODER
    422     register_avcodec(&msrle_decoder);
    423 #endif //CONFIG_MSRLE_DECODER
    424 #ifdef CONFIG_MSVIDEO1_DECODER
    425     register_avcodec(&msvideo1_decoder);
    426 #endif //CONFIG_MSVIDEO1_DECODER
    427 #ifdef CONFIG_VQA_DECODER
    428     register_avcodec(&vqa_decoder);
    429 #endif //CONFIG_VQA_DECODER
    430 #ifdef CONFIG_IDCIN_DECODER
    431     register_avcodec(&idcin_decoder);
    432 #endif //CONFIG_IDCIN_DECODER
    433 #ifdef CONFIG_EIGHTBPS_DECODER
    434     register_avcodec(&eightbps_decoder);
    435 #endif //CONFIG_EIGHTBPS_DECODER
    436 #ifdef CONFIG_SMC_DECODER
    437     register_avcodec(&smc_decoder);
    438 #endif //CONFIG_SMC_DECODER
    439 #ifdef CONFIG_FLIC_DECODER
    440     register_avcodec(&flic_decoder);
    441 #endif //CONFIG_FLIC_DECODER
    442 #ifdef CONFIG_TRUEMOTION1_DECODER
    443     register_avcodec(&truemotion1_decoder);
    444 #endif //CONFIG_TRUEMOTION1_DECODER
    445 #ifdef CONFIG_TRUEMOTION2_DECODER
    446     register_avcodec(&truemotion2_decoder);
    447 #endif //CONFIG_TRUEMOTION2_DECODER
    448 #ifdef CONFIG_VMDVIDEO_DECODER
    449     register_avcodec(&vmdvideo_decoder);
    450 #endif //CONFIG_VMDVIDEO_DECODER
    451 #ifdef CONFIG_VMDAUDIO_DECODER
    452     register_avcodec(&vmdaudio_decoder);
    453 #endif //CONFIG_VMDAUDIO_DECODER
    454 #ifdef CONFIG_MSZH_DECODER
    455     register_avcodec(&mszh_decoder);
    456 #endif //CONFIG_MSZH_DECODER
    457 #ifdef CONFIG_ZLIB_DECODER
    458     register_avcodec(&zlib_decoder);
    459 #endif //CONFIG_ZLIB_DECODER
    460 #ifdef CONFIG_ZMBV_DECODER
    461     register_avcodec(&zmbv_decoder);
    462 #endif //CONFIG_ZMBV_DECODER
    463 #ifdef CONFIG_SMACKER_DECODER
    464     register_avcodec(&smacker_decoder);
    465 #endif //CONFIG_SMACKER_DECODER
    466 #ifdef CONFIG_SMACKAUD_DECODER
    467     register_avcodec(&smackaud_decoder);
    468 #endif //CONFIG_SMACKAUD_DECODER
    469 #ifdef CONFIG_SONIC_DECODER
    470     register_avcodec(&sonic_decoder);
    471 #endif //CONFIG_SONIC_DECODER
    472 #ifdef CONFIG_A52
    473 #ifdef CONFIG_AC3_DECODER
    474     register_avcodec(&ac3_decoder);
    475 #endif //CONFIG_AC3_DECODER
    476 #endif
    477 #ifdef CONFIG_DTS
    478 #ifdef CONFIG_DTS_DECODER
    479     register_avcodec(&dts_decoder);
    480 #endif //CONFIG_DTS_DECODER
    481 #endif
    482 #ifdef CONFIG_RA_144_DECODER
    483     register_avcodec(&ra_144_decoder);
    484 #endif //CONFIG_RA_144_DECODER
    485 #ifdef CONFIG_RA_288_DECODER
    486     register_avcodec(&ra_288_decoder);
    487 #endif //CONFIG_RA_288_DECODER
    488 #ifdef CONFIG_ROQ_DPCM_DECODER
    489     register_avcodec(&roq_dpcm_decoder);
    490 #endif //CONFIG_ROQ_DPCM_DECODER
    491 #ifdef CONFIG_INTERPLAY_DPCM_DECODER
    492     register_avcodec(&interplay_dpcm_decoder);
    493 #endif //CONFIG_INTERPLAY_DPCM_DECODER
    494 #ifdef CONFIG_XAN_DPCM_DECODER
    495     register_avcodec(&xan_dpcm_decoder);
    496 #endif //CONFIG_XAN_DPCM_DECODER
    497 #ifdef CONFIG_SOL_DPCM_DECODER
    498     register_avcodec(&sol_dpcm_decoder);
    499 #endif //CONFIG_SOL_DPCM_DECODER
    500 #ifdef CONFIG_QTRLE_DECODER
    501     register_avcodec(&qtrle_decoder);
    502 #endif //CONFIG_QTRLE_DECODER
    503 #ifdef CONFIG_FLAC_DECODER
    504     register_avcodec(&flac_decoder);
    505 #endif //CONFIG_FLAC_DECODER
    506 #ifdef CONFIG_SHORTEN_DECODER
    507     register_avcodec(&shorten_decoder);
    508 #endif //CONFIG_SHORTEN_DECODER
    509 #ifdef CONFIG_ALAC_DECODER
    510     register_avcodec(&alac_decoder);
    511 #endif //CONFIG_ALAC_DECODER
    512 #ifdef CONFIG_WS_SND1_DECODER
    513     register_avcodec(&ws_snd1_decoder);
    514 #endif //CONFIG_WS_SND1_DECODER
    515 #ifdef CONFIG_VORBIS_DECODER
    516     register_avcodec(&vorbis_decoder);
    517 #endif
    518 #ifdef CONFIG_VORBIS_ENCODER
    519     register_avcodec(&vorbis_encoder);
    520 #endif
    521 #ifdef CONFIG_LIBGSM
    522     register_avcodec(&libgsm_decoder);
    523 #endif //CONFIG_LIBGSM
    524 #ifdef CONFIG_QDM2_DECODER
    525     register_avcodec(&qdm2_decoder);
    526 #endif //CONFIG_QDM2_DECODER
    527 #ifdef CONFIG_COOK_DECODER
    528     register_avcodec(&cook_decoder);
    529 #endif //CONFIG_COOK_DECODER
    530 #ifdef CONFIG_TRUESPEECH_DECODER
    531     register_avcodec(&truespeech_decoder);
    532 #endif //CONFIG_TRUESPEECH_DECODER
    533 #ifdef CONFIG_TTA_DECODER
    534     register_avcodec(&tta_decoder);
    535 #endif //CONFIG_TTA_DECODER
    536 #ifdef CONFIG_AVS_DECODER
    537     register_avcodec(&avs_decoder);
    538 #endif //CONFIG_AVS_DECODER
    539 #ifdef CONFIG_CAVS_DECODER
    540     register_avcodec(&cavs_decoder);
    541 #endif //CONFIG_CAVS_DECODER
    542 #ifdef CONFIG_RAWVIDEO_DECODER
    543     register_avcodec(&rawvideo_decoder);
    544 #endif //CONFIG_RAWVIDEO_DECODER
    545 #ifdef CONFIG_FLASHSV_DECODER
    546     register_avcodec(&flashsv_decoder);
    547 #endif //CONFIG_FLASHSV_DECODER
    548 #ifdef CONFIG_VMNC_DECODER
    549     register_avcodec(&vmnc_decoder);
    550 #endif //CONFIG_VMNC_DECODER
    551 #ifdef CONFIG_WAVPACK_DECODER
    552     register_avcodec(&wavpack_decoder);
    553 #endif //CONFIG_WAVPACK_DECODER
    554 #ifdef CONFIG_TARGA_DECODER
    555     register_avcodec(&targa_decoder);
    556 #endif //CONFIG_TARGA_DECODER
    557 #ifdef CONFIG_DSICINVIDEO_DECODER
    558     register_avcodec(&dsicinvideo_decoder);
    559 #endif //CONFIG_DSICINVIDEO_DECODER
    560 #ifdef CONFIG_DSICINAUDIO_DECODER
    561     register_avcodec(&dsicinaudio_decoder);
    562 #endif //CONFIG_DSICINAUDIO_DECODER
    563 #ifdef CONFIG_TIERTEXSEQVIDEO_DECODER
    564     register_avcodec(&tiertexseqvideo_decoder);
    565 #endif //CONFIG_TIERTEXSEQVIDEO_DECODER
    566 #ifdef CONFIG_TIFF_DECODER
    567     register_avcodec(&tiff_decoder);
    568 #endif //CONFIG_TIFF_DECODER
    569 #ifdef CONFIG_IMC_DECODER
    570     register_avcodec(&imc_decoder);
    571 #endif //CONFIG_IMC_DECODER
    572 
    573 #if defined(CONFIG_AMR_NB) || defined(CONFIG_AMR_NB_FIXED)
    574 #ifdef CONFIG_AMR_NB_DECODER
    575     register_avcodec(&amr_nb_decoder);
    576 #endif //CONFIG_AMR_NB_DECODER
    577 #ifdef CONFIG_AMR_NB_ENCODER
    578     register_avcodec(&amr_nb_encoder);
    579 #endif //CONFIG_AMR_NB_ENCODER
    580 #endif /* CONFIG_AMR_NB || CONFIG_AMR_NB_FIXED */
    581 
    582 #ifdef CONFIG_AMR_WB
    583 #ifdef CONFIG_AMR_WB_DECODER
    584     register_avcodec(&amr_wb_decoder);
    585 #endif //CONFIG_AMR_WB_DECODER
    586 #ifdef CONFIG_AMR_WB_ENCODER
    587     register_avcodec(&amr_wb_encoder);
    588 #endif //CONFIG_AMR_WB_ENCODER
    589 #endif /* CONFIG_AMR_WB */
    590 
    591 #ifdef CONFIG_BMP_DECODER
    592     register_avcodec(&bmp_decoder);
    593 #endif
    594 
    595 #if CONFIG_MMVIDEO_DECODER
    596     register_avcodec(&mmvideo_decoder);
    597 #endif //CONFIG_MMVIDEO_DECODER
     199    if (!ENABLE_VORBIS_ENCODER)  REGISTER_ENCODER(OGGVORBIS, oggvorbis);
     200    if (!ENABLE_VORBIS_DECODER)  REGISTER_DECODER(OGGVORBIS, oggvorbis);
     201#endif
     202    REGISTER_DECODER(QDM2, qdm2);
     203    REGISTER_DECODER(RA_144, ra_144);
     204    REGISTER_DECODER(RA_288, ra_288);
     205    REGISTER_DECODER(SHORTEN, shorten);
     206    REGISTER_DECODER(SMACKAUD, smackaud);
     207    REGISTER_ENCDEC (SONIC, sonic);
     208    REGISTER_ENCODER(SONIC_LS, sonic_ls);
     209    REGISTER_DECODER(TRUESPEECH, truespeech);
     210    REGISTER_DECODER(TTA, tta);
     211    REGISTER_DECODER(VMDAUDIO, vmdaudio);
     212    REGISTER_ENCDEC (VORBIS, vorbis);
     213    REGISTER_DECODER(WAVPACK, wavpack);
     214    REGISTER_DECODER(WMAV1, wmav1);
     215    REGISTER_DECODER(WMAV2, wmav2);
     216    REGISTER_DECODER(WS_SND1, ws_snd1);
    598217
    599218    /* pcm codecs */
    600 #ifdef CONFIG_PCM_S32LE_DECODER
    601     register_avcodec(&pcm_s32le_decoder);
    602 #endif
    603 #ifdef CONFIG_PCM_S32LE_ENCODER
    604     register_avcodec(&pcm_s32le_encoder);
    605 #endif
    606 #ifdef CONFIG_PCM_S32BE_DECODER
    607     register_avcodec(&pcm_s32be_decoder);
    608 #endif
    609 #ifdef CONFIG_PCM_S32BE_ENCODER
    610     register_avcodec(&pcm_s32be_encoder);
    611 #endif
    612 #ifdef CONFIG_PCM_U32LE_DECODER
    613     register_avcodec(&pcm_u32le_decoder);
    614 #endif
    615 #ifdef CONFIG_PCM_U32LE_ENCODER
    616     register_avcodec(&pcm_u32le_encoder);
    617 #endif
    618 #ifdef CONFIG_PCM_U32BE_DECODER
    619     register_avcodec(&pcm_u32be_decoder);
    620 #endif
    621 #ifdef CONFIG_PCM_U32BE_ENCODER
    622     register_avcodec(&pcm_u32be_encoder);
    623 #endif
    624 #ifdef CONFIG_PCM_S24LE_DECODER
    625     register_avcodec(&pcm_s24le_decoder);
    626 #endif
    627 #ifdef CONFIG_PCM_S24LE_ENCODER
    628     register_avcodec(&pcm_s24le_encoder);
    629 #endif
    630 #ifdef CONFIG_PCM_S24BE_DECODER
    631     register_avcodec(&pcm_s24be_decoder);
    632 #endif
    633 #ifdef CONFIG_PCM_S24BE_ENCODER
    634     register_avcodec(&pcm_s24be_encoder);
    635 #endif
    636 #ifdef CONFIG_PCM_U24LE_DECODER
    637     register_avcodec(&pcm_u24le_decoder);
    638 #endif
    639 #ifdef CONFIG_PCM_U24LE_ENCODER
    640     register_avcodec(&pcm_u24le_encoder);
    641 #endif
    642 #ifdef CONFIG_PCM_U24BE_DECODER
    643     register_avcodec(&pcm_u24be_decoder);
    644 #endif
    645 #ifdef CONFIG_PCM_U24BE_ENCODER
    646     register_avcodec(&pcm_u24be_encoder);
    647 #endif
    648 #ifdef CONFIG_PCM_S24DAUD_DECODER
    649     register_avcodec(&pcm_s24daud_decoder);
    650 #endif
    651 #ifdef CONFIG_PCM_S24DAUD_ENCODER
    652     register_avcodec(&pcm_s24daud_encoder);
    653 #endif
    654 #ifdef CONFIG_PCM_S16LE_DECODER
    655     register_avcodec(&pcm_s16le_decoder);
    656 #endif
    657 #ifdef CONFIG_PCM_S16LE_ENCODER
    658     register_avcodec(&pcm_s16le_encoder);
    659 #endif
    660 #ifdef CONFIG_PCM_S16BE_DECODER
    661     register_avcodec(&pcm_s16be_decoder);
    662 #endif
    663 #ifdef CONFIG_PCM_S16BE_ENCODER
    664     register_avcodec(&pcm_s16be_encoder);
    665 #endif
    666 #ifdef CONFIG_PCM_U16LE_DECODER
    667     register_avcodec(&pcm_u16le_decoder);
    668 #endif
    669 #ifdef CONFIG_PCM_U16LE_ENCODER
    670     register_avcodec(&pcm_u16le_encoder);
    671 #endif
    672 #ifdef CONFIG_PCM_U16BE_DECODER
    673     register_avcodec(&pcm_u16be_decoder);
    674 #endif
    675 #ifdef CONFIG_PCM_U16BE_ENCODER
    676     register_avcodec(&pcm_u16be_encoder);
    677 #endif
    678 #ifdef CONFIG_PCM_S8_DECODER
    679     register_avcodec(&pcm_s8_decoder);
    680 #endif
    681 #ifdef CONFIG_PCM_S8_ENCODER
    682     register_avcodec(&pcm_s8_encoder);
    683 #endif
    684 #ifdef CONFIG_PCM_U8_DECODER
    685     register_avcodec(&pcm_u8_decoder);
    686 #endif
    687 #ifdef CONFIG_PCM_U8_ENCODER
    688     register_avcodec(&pcm_u8_encoder);
    689 #endif
    690 #ifdef CONFIG_PCM_ALAW_DECODER
    691     register_avcodec(&pcm_alaw_decoder);
    692 #endif
    693 #ifdef CONFIG_PCM_ALAW_ENCODER
    694     register_avcodec(&pcm_alaw_encoder);
    695 #endif
    696 #ifdef CONFIG_PCM_MULAW_DECODER
    697     register_avcodec(&pcm_mulaw_decoder);
    698 #endif
    699 #ifdef CONFIG_PCM_MULAW_ENCODER
    700     register_avcodec(&pcm_mulaw_encoder);
    701 #endif
    702 
    703    /* adpcm codecs */
    704 #ifdef CONFIG_ADPCM_IMA_QT_DECODER
    705     register_avcodec(&adpcm_ima_qt_decoder);
    706 #endif
    707 #ifdef CONFIG_ADPCM_IMA_QT_ENCODER
    708     register_avcodec(&adpcm_ima_qt_encoder);
    709 #endif
    710 #ifdef CONFIG_ADPCM_IMA_WAV_DECODER
    711     register_avcodec(&adpcm_ima_wav_decoder);
    712 #endif
    713 #ifdef CONFIG_ADPCM_IMA_WAV_ENCODER
    714     register_avcodec(&adpcm_ima_wav_encoder);
    715 #endif
    716 #ifdef CONFIG_ADPCM_IMA_DK3_DECODER
    717     register_avcodec(&adpcm_ima_dk3_decoder);
    718 #endif
    719 #ifdef CONFIG_ADPCM_IMA_DK3_ENCODER
    720     register_avcodec(&adpcm_ima_dk3_encoder);
    721 #endif
    722 #ifdef CONFIG_ADPCM_IMA_DK4_DECODER
    723     register_avcodec(&adpcm_ima_dk4_decoder);
    724 #endif
    725 #ifdef CONFIG_ADPCM_IMA_DK4_ENCODER
    726     register_avcodec(&adpcm_ima_dk4_encoder);
    727 #endif
    728 #ifdef CONFIG_ADPCM_IMA_WS_DECODER
    729     register_avcodec(&adpcm_ima_ws_decoder);
    730 #endif
    731 #ifdef CONFIG_ADPCM_IMA_WS_ENCODER
    732     register_avcodec(&adpcm_ima_ws_encoder);
    733 #endif
    734 #ifdef CONFIG_ADPCM_IMA_SMJPEG_DECODER
    735     register_avcodec(&adpcm_ima_smjpeg_decoder);
    736 #endif
    737 #ifdef CONFIG_ADPCM_IMA_SMJPEG_ENCODER
    738     register_avcodec(&adpcm_ima_smjpeg_encoder);
    739 #endif
    740 #ifdef CONFIG_ADPCM_MS_DECODER
    741     register_avcodec(&adpcm_ms_decoder);
    742 #endif
    743 #ifdef CONFIG_ADPCM_MS_ENCODER
    744     register_avcodec(&adpcm_ms_encoder);
    745 #endif
    746 #ifdef CONFIG_ADPCM_4XM_DECODER
    747     register_avcodec(&adpcm_4xm_decoder);
    748 #endif
    749 #ifdef CONFIG_ADPCM_4XM_ENCODER
    750     register_avcodec(&adpcm_4xm_encoder);
    751 #endif
    752 #ifdef CONFIG_ADPCM_XA_DECODER
    753     register_avcodec(&adpcm_xa_decoder);
    754 #endif
    755 #ifdef CONFIG_ADPCM_XA_ENCODER
    756     register_avcodec(&adpcm_xa_encoder);
    757 #endif
    758 #ifdef CONFIG_ADPCM_ADX_DECODER
    759     register_avcodec(&adpcm_adx_decoder);
    760 #endif
    761 #ifdef CONFIG_ADPCM_ADX_ENCODER
    762     register_avcodec(&adpcm_adx_encoder);
    763 #endif
    764 #ifdef CONFIG_ADPCM_EA_DECODER
    765     register_avcodec(&adpcm_ea_decoder);
    766 #endif
    767 #ifdef CONFIG_ADPCM_EA_ENCODER
    768     register_avcodec(&adpcm_ea_encoder);
    769 #endif
    770 #ifdef CONFIG_ADPCM_G726_DECODER
    771     register_avcodec(&adpcm_g726_decoder);
    772 #endif
    773 #ifdef CONFIG_ADPCM_G726_ENCODER
    774     register_avcodec(&adpcm_g726_encoder);
    775 #endif
    776 #ifdef CONFIG_ADPCM_CT_DECODER
    777     register_avcodec(&adpcm_ct_decoder);
    778 #endif
    779 #ifdef CONFIG_ADPCM_CT_ENCODER
    780     register_avcodec(&adpcm_ct_encoder);
    781 #endif
    782 #ifdef CONFIG_ADPCM_SWF_DECODER
    783     register_avcodec(&adpcm_swf_decoder);
    784 #endif
    785 #ifdef CONFIG_ADPCM_SWF_ENCODER
    786     register_avcodec(&adpcm_swf_encoder);
    787 #endif
    788 #ifdef CONFIG_ADPCM_YAMAHA_DECODER
    789     register_avcodec(&adpcm_yamaha_decoder);
    790 #endif
    791 #ifdef CONFIG_ADPCM_YAMAHA_ENCODER
    792     register_avcodec(&adpcm_yamaha_encoder);
    793 #endif
    794 #ifdef CONFIG_ADPCM_SBPRO_4_DECODER
    795     register_avcodec(&adpcm_sbpro_4_decoder);
    796 #endif
    797 #ifdef CONFIG_ADPCM_SBPRO_4_ENCODER
    798     register_avcodec(&adpcm_sbpro_4_encoder);
    799 #endif
    800 #ifdef CONFIG_ADPCM_SBPRO_3_DECODER
    801     register_avcodec(&adpcm_sbpro_3_decoder);
    802 #endif
    803 #ifdef CONFIG_ADPCM_SBPRO_3_ENCODER
    804     register_avcodec(&adpcm_sbpro_3_encoder);
    805 #endif
    806 #ifdef CONFIG_ADPCM_SBPRO_2_DECODER
    807     register_avcodec(&adpcm_sbpro_2_decoder);
    808 #endif
    809 #ifdef CONFIG_ADPCM_SBPRO_2_ENCODER
    810     register_avcodec(&adpcm_sbpro_2_encoder);
    811 #endif
     219    REGISTER_ENCDEC (PCM_ALAW, pcm_alaw);
     220    REGISTER_ENCDEC (PCM_MULAW, pcm_mulaw);
     221    REGISTER_ENCDEC (PCM_S8, pcm_s8);
     222    REGISTER_ENCDEC (PCM_S16BE, pcm_s16be);
     223    REGISTER_ENCDEC (PCM_S16LE, pcm_s16le);
     224    REGISTER_ENCDEC (PCM_S24BE, pcm_s24be);
     225    REGISTER_ENCDEC (PCM_S24DAUD, pcm_s24daud);
     226    REGISTER_ENCDEC (PCM_S24LE, pcm_s24le);
     227    REGISTER_ENCDEC (PCM_S32BE, pcm_s32be);
     228    REGISTER_ENCDEC (PCM_S32LE, pcm_s32le);
     229    REGISTER_ENCDEC (PCM_U8, pcm_u8);
     230    REGISTER_ENCDEC (PCM_U16BE, pcm_u16be);
     231    REGISTER_ENCDEC (PCM_U16LE, pcm_u16le);
     232    REGISTER_ENCDEC (PCM_U24BE, pcm_u24be);
     233    REGISTER_ENCDEC (PCM_U24LE, pcm_u24le);
     234    REGISTER_ENCDEC (PCM_U32BE, pcm_u32be);
     235    REGISTER_ENCDEC (PCM_U32LE, pcm_u32le);
     236
     237    /* dpcm codecs */
     238    REGISTER_DECODER(INTERPLAY_DPCM, interplay_dpcm);
     239    REGISTER_DECODER(ROQ_DPCM, roq_dpcm);
     240    REGISTER_DECODER(SOL_DPCM, sol_dpcm);
     241    REGISTER_DECODER(XAN_DPCM, xan_dpcm);
     242
     243    /* adpcm codecs */
     244    REGISTER_ENCDEC (ADPCM_4XM, adpcm_4xm);
     245    REGISTER_ENCDEC (ADPCM_ADX, adpcm_adx);
     246    REGISTER_ENCDEC (ADPCM_CT, adpcm_ct);
     247    REGISTER_ENCDEC (ADPCM_EA, adpcm_ea);
     248    REGISTER_ENCDEC (ADPCM_G726, adpcm_g726);
     249    REGISTER_ENCDEC (ADPCM_IMA_DK3, adpcm_ima_dk3);
     250    REGISTER_ENCDEC (ADPCM_IMA_DK4, adpcm_ima_dk4);
     251    REGISTER_ENCDEC (ADPCM_IMA_QT, adpcm_ima_qt);
     252    REGISTER_ENCDEC (ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg);
     253    REGISTER_ENCDEC (ADPCM_IMA_WAV, adpcm_ima_wav);
     254    REGISTER_ENCDEC (ADPCM_IMA_WS, adpcm_ima_ws);
     255    REGISTER_ENCDEC (ADPCM_MS, adpcm_ms);
     256    REGISTER_ENCDEC (ADPCM_SBPRO_2, adpcm_sbpro_2);
     257    REGISTER_ENCDEC (ADPCM_SBPRO_3, adpcm_sbpro_3);
     258    REGISTER_ENCDEC (ADPCM_SBPRO_4, adpcm_sbpro_4);
     259    REGISTER_ENCDEC (ADPCM_SWF, adpcm_swf);
     260    REGISTER_ENCDEC (ADPCM_XA, adpcm_xa);
     261    REGISTER_ENCDEC (ADPCM_YAMAHA, adpcm_yamaha);
    812262
    813263    /* subtitles */
    814 #ifdef CONFIG_DVDSUB_DECODER
    815     register_avcodec(&dvdsub_decoder);
    816 #endif
    817 #ifdef CONFIG_DVDSUB_ENCODER
    818     register_avcodec(&dvdsub_encoder);
    819 #endif
    820 
    821 #ifdef CONFIG_DVBSUB_DECODER
    822     register_avcodec(&dvbsub_decoder);
    823 #endif
    824 #ifdef CONFIG_DVBSUB_ENCODER
    825     register_avcodec(&dvbsub_encoder);
    826 #endif
     264    REGISTER_ENCDEC (DVBSUB, dvbsub);
     265    REGISTER_ENCDEC (DVDSUB, dvdsub);
    827266
    828267    /* parsers */
    829 #ifdef CONFIG_MPEGVIDEO_PARSER
    830     av_register_codec_parser(&mpegvideo_parser);
    831 #endif
    832 #ifdef CONFIG_MPEG4VIDEO_PARSER
    833     av_register_codec_parser(&mpeg4video_parser);
    834 #endif
    835 #ifdef CONFIG_CAVSVIDEO_PARSER
    836     av_register_codec_parser(&cavsvideo_parser);
    837 #endif
    838 #ifdef CONFIG_H261_PARSER
    839     av_register_codec_parser(&h261_parser);
    840 #endif
    841 #ifdef CONFIG_H263_PARSER
    842     av_register_codec_parser(&h263_parser);
    843 #endif
    844 #ifdef CONFIG_H264_PARSER
    845     av_register_codec_parser(&h264_parser);
    846 #endif
    847 #ifdef CONFIG_MJPEG_PARSER
    848     av_register_codec_parser(&mjpeg_parser);
    849 #endif
    850 #ifdef CONFIG_PNM_PARSER
    851     av_register_codec_parser(&pnm_parser);
    852 #endif
    853 #ifdef CONFIG_MPEGAUDIO_PARSER
    854     av_register_codec_parser(&mpegaudio_parser);
    855 #endif
    856 #ifdef CONFIG_AC3_PARSER
    857     av_register_codec_parser(&ac3_parser);
    858 #endif
    859 #ifdef CONFIG_DVDSUB_PARSER
    860     av_register_codec_parser(&dvdsub_parser);
    861 #endif
    862 #ifdef CONFIG_DVBSUB_PARSER
    863     av_register_codec_parser(&dvbsub_parser);
    864 #endif
    865 #ifdef CONFIG_AAC_PARSER
    866     av_register_codec_parser(&aac_parser);
    867 #endif
     268    REGISTER_PARSER (AAC, aac);
     269    REGISTER_PARSER (AC3, ac3);
     270    REGISTER_PARSER (CAVSVIDEO, cavsvideo);
     271    REGISTER_PARSER (DVBSUB, dvbsub);
     272    REGISTER_PARSER (DVDSUB, dvdsub);
     273    REGISTER_PARSER (H261, h261);
     274    REGISTER_PARSER (H263, h263);
     275    REGISTER_PARSER (H264, h264);
     276    REGISTER_PARSER (MJPEG, mjpeg);
     277    REGISTER_PARSER (MPEG4VIDEO, mpeg4video);
     278    REGISTER_PARSER (MPEGAUDIO, mpegaudio);
     279    REGISTER_PARSER (MPEGVIDEO, mpegvideo);
     280    REGISTER_PARSER (PNM, pnm);
    868281
    869282    av_register_bitstream_filter(&dump_extradata_bsf);
    … …  
    872285    av_register_bitstream_filter(&mp3_header_compress_bsf);
    873286    av_register_bitstream_filter(&mp3_header_decompress_bsf);
     287    av_register_bitstream_filter(&mjpega_dump_header_bsf);
    874288}
    875289

  • TabularUnified trunk/libavcodec/amr.c

    r261 r269  
    483483    int written;
    484484
     485    s->enc_bitrate=getBitrateMode(avctx->bit_rate);
     486
    485487    written = Encoder_Interface_Encode(s->enstate,
    486488        s->enc_bitrate,
    … …  
    624626                            unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
    625627{
    626     AMRWBContext *s = (AMRWBContext*) avctx->priv_data;
    627     int size = E_IF_encode(s->state, s->mode, data, frame, s->allow_dtx);
     628    AMRWBContext *s;
     629    int size;
     630    s = (AMRWBContext*) avctx->priv_data;
     631    s->mode=getWBBitrateMode(avctx->bit_rate);
     632    size = E_IF_encode(s->state, s->mode, data, frame, s->allow_dtx);
    628633    return size;
    629634}

  • TabularUnified trunk/libavcodec/avcodec.h

    r263 r269  
    3131extern "C" {
    3232#endif
    33 
    3433#include "config.h"
    3534#include "avutil.h"
    … …  
    26662665extern AVBitStreamFilter mp3_header_compress_bsf;
    26672666extern AVBitStreamFilter mp3_header_decompress_bsf;
     2667extern AVBitStreamFilter mjpega_dump_header_bsf;
    26682668
    26692669

  • TabularUnified trunk/libavcodec/cabac.h

    r261 r269  
    378378#endif
    379379#if 0
    380 //    defined(ARCH_X86) && !(defined(PIC) && defined(__GNUC__))
     380    //defined(ARCH_X86) && !(defined(PIC) && defined(__GNUC__))
    381381    int bit;
    382382
    … …  
    634634
    635635static always_inline int get_cabac_bypass_sign(CABACContext *c, int val){
    636 #ifdef ARCH_X86
     636#if defined(ARCH_X86) && !(defined(PIC) && defined(__GNUC__))
    637637    asm volatile(
    638638        "movl "RANGE    "(%1), %%ebx            \n\t"

  • TabularUnified trunk/libavcodec/cinepak.c

    r256 r269  
    2727 * For more information on the Cinepak algorithm, visit:
    2828 *   http://www.csse.monash.edu.au/~timf/
     29 * For more information on the quirky data inside Sega FILM/CPK files, visit:
     30 *   http://wiki.multimedia.cx/index.php?title=Sega_FILM
    2931 */
    3032
    … …  
    6769    int palette_video;
    6870    cvid_strip_t strips[MAX_STRIPS];
     71
     72    int sega_film_skip_bytes;
    6973
    7074} CinepakContext;
    … …  
    320324    int           y0 = 0;
    321325    int           encoded_buf_size;
    322     /* if true, Cinepak data is from a Sega FILM/CPK file */
    323     int           sega_film_data = 0;
    324326
    325327    if (s->size < 10)
    … …  
    329331    num_strips  = BE_16 (&s->data[8]);
    330332    encoded_buf_size = ((s->data[1] << 16) | BE_16 (&s->data[2]));
    331     if (encoded_buf_size != s->size)
    332         sega_film_data = 1;
    333     if (sega_film_data)
    334         s->data    += 12;
    335     else
    336         s->data    += 10;
     333
     334    /* if this is the first frame, check for deviant Sega FILM data */
     335    if (s->sega_film_skip_bytes == -1) {
     336        if (encoded_buf_size != s->size) {
     337            /* If the encoded frame size differs from the frame size as indicated
     338             * by the container file, this data likely comes from a Sega FILM/CPK file.
     339             * If the frame header is followed by the bytes FE 00 00 06 00 00 then
     340             * this is probably one of the two known files that have 6 extra bytes
     341             * after the frame header. Else, assume 2 extra bytes. */
     342            if ((s->data[10] == 0xFE) &&
     343                (s->data[11] == 0x00) &&
     344                (s->data[12] == 0x00) &&
     345                (s->data[13] == 0x06) &&
     346                (s->data[14] == 0x00) &&
     347                (s->data[15] == 0x00))
     348                s->sega_film_skip_bytes = 6;
     349            else
     350                s->sega_film_skip_bytes = 2;
     351        } else
     352            s->sega_film_skip_bytes = 0;
     353    }
     354
     355    s->data += 10 + s->sega_film_skip_bytes;
    337356
    338357    if (num_strips > MAX_STRIPS)
    … …  
    378397    s->width = (avctx->width + 3) & ~3;
    379398    s->height = (avctx->height + 3) & ~3;
     399    s->sega_film_skip_bytes = -1;  /* uninitialized state */
    380400
    381401    // check for paletted data

  • TabularUnified trunk/libavcodec/dsputil.c

    r263 r269  
    15131513    }
    15141514}
    1515 
    1516 static inline void copy_block2(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
    1517 {
    1518     int i;
    1519     for(i=0; i<h; i++)
    1520     {
    1521         ST16(dst   , LD16(src   ));
    1522         dst+=dstStride;
    1523         src+=srcStride;
    1524     }
    1525 }
    1526 
    1527 static inline void copy_block4(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
    1528 {
    1529     int i;
    1530     for(i=0; i<h; i++)
    1531     {
    1532         ST32(dst   , LD32(src   ));
    1533         dst+=dstStride;
    1534         src+=srcStride;
    1535     }
    1536 }
    1537 
    1538 static inline void copy_block8(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
    1539 {
    1540     int i;
    1541     for(i=0; i<h; i++)
    1542     {
    1543         ST32(dst   , LD32(src   ));
    1544         ST32(dst+4 , LD32(src+4 ));
    1545         dst+=dstStride;
    1546         src+=srcStride;
    1547     }
    1548 }
    1549 
    1550 static inline void copy_block16(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
    1551 {
    1552     int i;
    1553     for(i=0; i<h; i++)
    1554     {
    1555         ST32(dst   , LD32(src   ));
    1556         ST32(dst+4 , LD32(src+4 ));
    1557         ST32(dst+8 , LD32(src+8 ));
    1558         ST32(dst+12, LD32(src+12));
    1559         dst+=dstStride;
    1560         src+=srcStride;
    1561     }
    1562 }
    1563 
    1564 static inline void copy_block17(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
    1565 {
    1566     int i;
    1567     for(i=0; i<h; i++)
    1568     {
    1569         ST32(dst   , LD32(src   ));
    1570         ST32(dst+4 , LD32(src+4 ));
    1571         ST32(dst+8 , LD32(src+8 ));
    1572         ST32(dst+12, LD32(src+12));
    1573         dst[16]= src[16];
    1574         dst+=dstStride;
    1575         src+=srcStride;
    1576     }
    1577 }
    1578 
    1579 static inline void copy_block9(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
    1580 {
    1581     int i;
    1582     for(i=0; i<h; i++)
    1583     {
    1584         ST32(dst   , LD32(src   ));
    1585         ST32(dst+4 , LD32(src+4 ));
    1586         dst[8]= src[8];
    1587         dst+=dstStride;
    1588         src+=srcStride;
    1589     }
    1590 }
    1591 
    15921515
    15931516#define QPEL_MC(r, OPNAME, RND, OP) \

  • TabularUnified trunk/libavcodec/dsputil.h

    r263 r269  
    398398    void (*vc1_inv_trans_4x8)(DCTELEM *b, int n);
    399399    void (*vc1_inv_trans_4x4)(DCTELEM *b, int n);
    400     void (*vc1_v_overlap)(uint8_t* src, int stride, int rnd);
    401     void (*vc1_h_overlap)(uint8_t* src, int stride, int rnd);
     400    void (*vc1_v_overlap)(uint8_t* src, int stride);
     401    void (*vc1_h_overlap)(uint8_t* src, int stride);
    402402    /* put 8x8 block with bicubic interpolation and quarterpel precision
    403403     * last argument is actually round value instead of height
    … …  
    699699}
    700700
     701
     702static inline void copy_block2(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
     703{
     704    int i;
     705    for(i=0; i<h; i++)
     706    {
     707        ST16(dst   , LD16(src   ));
     708        dst+=dstStride;
     709        src+=srcStride;
     710    }
     711}
     712
     713static inline void copy_block4(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
     714{
     715    int i;
     716    for(i=0; i<h; i++)
     717    {
     718        ST32(dst   , LD32(src   ));
     719        dst+=dstStride;
     720        src+=srcStride;
     721    }
     722}
     723
     724static inline void copy_block8(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
     725{
     726    int i;
     727    for(i=0; i<h; i++)
     728    {
     729        ST32(dst   , LD32(src   ));
     730        ST32(dst+4 , LD32(src+4 ));
     731        dst+=dstStride;
     732        src+=srcStride;
     733    }
     734}
     735
     736static inline void copy_block9(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
     737{
     738    int i;
     739    for(i=0; i<h; i++)
     740    {
     741        ST32(dst   , LD32(src   ));
     742        ST32(dst+4 , LD32(src+4 ));
     743        dst[8]= src[8];
     744        dst+=dstStride;
     745        src+=srcStride;
     746    }
     747}
     748
     749static inline void copy_block16(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
     750{
     751    int i;
     752    for(i=0; i<h; i++)
     753    {
     754        ST32(dst   , LD32(src   ));
     755        ST32(dst+4 , LD32(src+4 ));
     756        ST32(dst+8 , LD32(src+8 ));
     757        ST32(dst+12, LD32(src+12));
     758        dst+=dstStride;
     759        src+=srcStride;
     760    }
     761}
     762
     763static inline void copy_block17(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
     764{
     765    int i;
     766    for(i=0; i<h; i++)
     767    {
     768        ST32(dst   , LD32(src   ));
     769        ST32(dst+4 , LD32(src+4 ));
     770        ST32(dst+8 , LD32(src+8 ));
     771        ST32(dst+12, LD32(src+12));
     772        dst[16]= src[16];
     773        dst+=dstStride;
     774        src+=srcStride;
     775    }
     776}
     777
    701778#endif

  • TabularUnified trunk/libavcodec/flac.c

    r256 r269  
    9696
    9797static void metadata_streaminfo(FLACContext *s);
    98 static void dump_headers(FLACContext *s);
     98static void allocate_buffers(FLACContext *s);
     99static int metadata_parse(FLACContext *s);
    99100
    100101static int flac_decode_init(AVCodecContext * avctx)
    … …  
    103104    s->avctx = avctx;
    104105
    105     /* initialize based on the demuxer-supplied streamdata header */
    106     if (avctx->extradata_size == FLAC_STREAMINFO_SIZE) {
     106    if (avctx->extradata_size > 4) {
     107        /* initialize based on the demuxer-supplied streamdata header */
    107108        init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
    108         metadata_streaminfo(s);
    109         dump_headers(s);
     109        if (avctx->extradata_size == FLAC_STREAMINFO_SIZE) {
     110            metadata_streaminfo(s);
     111            allocate_buffers(s);
     112        } else {
     113            metadata_parse(s);
     114        }
    110115    }
    111116
    … …  
    160165    skip_bits(&s->gb, 64); /* md5 sum */
    161166
    162     allocate_buffers(s);
     167    dump_headers(s);
     168}
     169
     170/**
     171 * Parse a list of metadata blocks. This list of blocks must begin with
     172 * the fLaC marker.
     173 * @param s the flac decoding context containing the gb bit reader used to
     174 *          parse metadata
     175 * @return 1 if some metadata was read, 0 if no fLaC marker was found
     176 */
     177static int metadata_parse(FLACContext *s)
     178{
     179    int i, metadata_last, metadata_type, metadata_size, streaminfo_updated=0;
     180
     181    if (show_bits_long(&s->gb, 32) == MKBETAG('f','L','a','C')) {
     182        skip_bits(&s->gb, 32);
     183
     184        av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n");
     185        do {
     186            metadata_last = get_bits(&s->gb, 1);
     187            metadata_type = get_bits(&s->gb, 7);
     188            metadata_size = get_bits_long(&s->gb, 24);
     189
     190            av_log(s->avctx, AV_LOG_DEBUG,
     191                   " metadata block: flag = %d, type = %d, size = %d\n",
     192                   metadata_last, metadata_type, metadata_size);
     193            if (metadata_size) {
     194                switch (metadata_type) {
     195                case METADATA_TYPE_STREAMINFO:
     196                    metadata_streaminfo(s);
     197                    streaminfo_updated = 1;
     198                    break;
     199
     200                default:
     201                    for (i=0; i<metadata_size; i++)
     202                        skip_bits(&s->gb, 8);
     203                }
     204            }
     205        } while (!metadata_last);
     206
     207        if (streaminfo_updated)
     208            allocate_buffers(s);
     209        return 1;
     210    }
     211    return 0;
    163212}
    164213
    … …  
    529578{
    530579    FLACContext *s = avctx->priv_data;
    531     int metadata_last, metadata_type, metadata_size;
    532580    int tmp = 0, i, j = 0, input_buf_size = 0;
    533581    int16_t *samples = data;
    … …  
    560608    init_get_bits(&s->gb, buf, buf_size*8);
    561609
    562     /* fLaC signature (be) */
    563     if (show_bits_long(&s->gb, 32) == bswap_32(ff_get_fourcc("fLaC")))
    564     {
    565         skip_bits(&s->gb, 32);
    566 
    567         av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n");
    568         do {
    569             metadata_last = get_bits(&s->gb, 1);
    570             metadata_type = get_bits(&s->gb, 7);
    571             metadata_size = get_bits_long(&s->gb, 24);
    572 
    573             av_log(s->avctx, AV_LOG_DEBUG, " metadata block: flag = %d, type = %d, size = %d\n",
    574                 metadata_last, metadata_type,
    575                 metadata_size);
    576             if(metadata_size){
    577                 switch(metadata_type)
    578                 {
    579                 case METADATA_TYPE_STREAMINFO:{
    580                     metadata_streaminfo(s);
    581 
    582                     /* Buffer might have been reallocated, reinit bitreader */
    583                     if(buf != &s->bitstream[s->bitstream_index])
    584                     {
    585                         int bits_count = get_bits_count(&s->gb);
    586                         buf= &s->bitstream[s->bitstream_index];
    587                         init_get_bits(&s->gb, buf, buf_size*8);
    588                         skip_bits(&s->gb, bits_count);
    589                     }
    590 
    591                     dump_headers(s);
    592                     break;}
    593                 default:
    594                     for(i=0; i<metadata_size; i++)
    595                         skip_bits(&s->gb, 8);
    596                 }
    597             }
    598         } while(!metadata_last);
    599     }
    600     else
    601     {
    602 
     610    if (!metadata_parse(s))
     611    {
    603612        tmp = show_bits(&s->gb, 16);
    604613        if(tmp != 0xFFF8){

  • TabularUnified trunk/libavcodec/flicvideo.c

    r263 r269  
    247247                line_packets = LE_16(&buf[stream_ptr]);
    248248                stream_ptr += 2;
    249                 if (line_packets < 0) {
     249                if ((line_packets & 0xC000) == 0xC000) {
     250                    // line skip opcode
    250251                    line_packets = -line_packets;
    251252                    y_ptr += line_packets * s->frame.linesize[0];
     253                } else if ((line_packets & 0xC000) == 0x4000) {
     254                    av_log(avctx, AV_LOG_ERROR, "Undefined opcode (%x) in DELTA_FLI\n", line_packets);
     255                } else if ((line_packets & 0xC000) == 0x8000) {
     256                    // "last byte" opcode
     257                    pixels[y_ptr + s->frame.linesize[0] - 1] = line_packets & 0xff;
    252258                } else {
    253259                    compressed_lines--;
    … …  
    309315                                pixels[pixel_ptr++] = palette_idx1;
    310316                            }
    311                         } else {
     317                        } else if (byte_run < 0) {
    312318                            byte_run = -byte_run;
    313319                            palette_idx1 = buf[stream_ptr++];
    … …  
    535541
    536542        case FLI_BLACK:
    537             /* set the whole frame to 0x0000 which is balck in both 15Bpp and 16Bpp modes. */
     543            /* set the whole frame to 0x0000 which is black in both 15Bpp and 16Bpp modes. */
    538544            memset(pixels, 0x0000,
    539                    s->frame.linesize[0] * s->avctx->height * 2);
     545                   s->frame.linesize[0] * s->avctx->height);
    540546            break;
    541547

  • TabularUnified trunk/libavcodec/mjpeg.c

    r263 r269  
    3737#include "dsputil.h"
    3838#include "mpegvideo.h"
     39#include "bytestream.h"
    3940
    4041/* use two quantizer tables (one for luminance and one for chrominance) */
    … …  
    16441645        return -1;
    16451646    }
    1646     /* XXX: only interleaved scan accepted */
    1647     if ((nb_components != s->nb_components) && !s->ls && !s->progressive)
    1648     {
    1649         dprintf("decode_sos: components(%d) mismatch\n", nb_components);
    1650         return -1;
    1651     }
    16521647    vmax = 0;
    16531648    hmax = 0;
    … …  
    17101705        s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
    17111706    } else if(!s->ls) { /* skip this for JPEG-LS */
    1712         h = s->h_max / s->h_scount[s->comp_index[0]];
    1713         v = s->v_max / s->v_scount[s->comp_index[0]];
     1707        h = s->h_max / s->h_scount[0];
     1708        v = s->v_max / s->v_scount[0];
    17141709        s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
    17151710        s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
    … …  
    25102505}
    25112506
     2507static int mjpega_dump_header(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args,
     2508                              uint8_t **poutbuf, int *poutbuf_size,
     2509                              const uint8_t *buf, int buf_size, int keyframe)
     2510{
     2511    uint8_t *poutbufp;
     2512    int i;
     2513
     2514    if (avctx->codec_id != CODEC_ID_MJPEG) {
     2515        av_log(avctx, AV_LOG_ERROR, "mjpega bitstream filter only applies to mjpeg codec\n");
     2516        return 0;
     2517    }
     2518
     2519    *poutbuf_size = 0;
     2520    *poutbuf = av_malloc(buf_size + 44 + FF_INPUT_BUFFER_PADDING_SIZE);
     2521    poutbufp = *poutbuf;
     2522    bytestream_put_byte(&poutbufp, 0xff);
     2523    bytestream_put_byte(&poutbufp, SOI);
     2524    bytestream_put_byte(&poutbufp, 0xff);
     2525    bytestream_put_byte(&poutbufp, APP1);
     2526    bytestream_put_be16(&poutbufp, 42); /* size */
     2527    bytestream_put_be32(&poutbufp, 0);
     2528    bytestream_put_buffer(&poutbufp, "mjpg", 4);
     2529    bytestream_put_be32(&poutbufp, buf_size + 44); /* field size */
     2530    bytestream_put_be32(&poutbufp, buf_size + 44); /* pad field size */
     2531    bytestream_put_be32(&poutbufp, 0);             /* next ptr */
     2532
     2533    for (i = 0; i < buf_size - 1; i++) {
     2534        if (buf[i] == 0xff) {
     2535            switch (buf[i + 1]) {
     2536            case DQT:  /* quant off */
     2537            case DHT:  /* huff  off */
     2538            case SOF0: /* image off */
     2539                bytestream_put_be32(&poutbufp, i + 46);
     2540                break;
     2541            case SOS:
     2542                bytestream_put_be32(&poutbufp, i + 46); /* scan off */
     2543                bytestream_put_be32(&poutbufp, i + 46 + BE_16(buf + i + 2)); /* data off */
     2544                bytestream_put_buffer(&poutbufp, buf + 2, buf_size - 2); /* skip already written SOI */
     2545                *poutbuf_size = poutbufp - *poutbuf;
     2546                return 1;
     2547            case APP1:
     2548                if (i + 8 < buf_size && LE_32(buf + i + 8) == ff_get_fourcc("mjpg")) {
     2549                    av_log(avctx, AV_LOG_ERROR, "bitstream already formatted\n");
     2550                    memcpy(*poutbuf, buf, buf_size);
     2551                    *poutbuf_size = buf_size;
     2552                    return 1;
     2553                }
     2554            }
     2555        }
     2556    }
     2557    av_freep(poutbuf);
     2558    av_log(avctx, AV_LOG_ERROR, "could not find SOS marker in bitstream\n");
     2559    return 0;
     2560}
     2561
    25122562AVCodec mjpeg_decoder = {
    25132563    "mjpeg",
    … …  
    25692619};
    25702620
     2621AVBitStreamFilter mjpega_dump_header_bsf = {
     2622    "mjpegadump",
     2623    0,
     2624    mjpega_dump_header,
     2625};

  • TabularUnified trunk/libavcodec/motion_est.c

    r261 r269  
    17871787
    17881788    /* special case for first line */
    1789     if (!s->first_slice_line) { //FIXME maybe allow this over thread boundary as its cliped
     1789    if (!s->first_slice_line) { //FIXME maybe allow this over thread boundary as its clipped
    17901790        P_TOP[0]      = clip(mv_table[mot_xy - mot_stride             ][0], xmin<<shift, xmax<<shift);
    17911791        P_TOP[1]      = clip(mv_table[mot_xy - mot_stride             ][1], ymin<<shift, ymax<<shift);

  • TabularUnified trunk/libavcodec/motion_est_template.c

    r257 r269  
    516516}
    517517
    518 #define CHECK_CLIPED_MV(ax,ay)\
     518#define CHECK_CLIPPED_MV(ax,ay)\
    519519{\
    520     const int x= ax;\
    521     const int y= ay;\
    522     const int x2= FFMAX(xmin, FFMIN(x, xmax));\
    523     const int y2= FFMAX(ymin, FFMIN(y, ymax));\
    524     CHECK_MV(x2, y2)\
     520    const int Lx= ax;\
     521    const int Ly= ay;\
     522    const int Lx2= FFMAX(xmin, FFMIN(Lx, xmax));\
     523    const int Ly2= FFMAX(ymin, FFMIN(Ly, ymax));\
     524    CHECK_MV(Lx2, Ly2)\
    525525}
    526526
    … …  
    657657    }
    658658    return dmin;
     659}
     660
     661static int hex_search(MpegEncContext * s, int *best, int dmin,
     662                                       int src_index, int ref_index, int const penalty_factor,
     663                                       int size, int h, int flags, int dia_size)
     664{
     665    MotionEstContext * const c= &s->me;
     666    me_cmp_func cmpf, chroma_cmpf;
     667    LOAD_COMMON
     668    LOAD_COMMON2
     669    int map_generation= c->map_generation;
     670    int x,y,i,d;
     671    static const int hex[6][2]={{-2, 0}, { 2,0}, {-1,-2}, {1,-2}, {-1,2},{1,2}};
     672
     673    cmpf= s->dsp.me_cmp[size];
     674    chroma_cmpf= s->dsp.me_cmp[size+1];
     675
     676    for(;dia_size; dia_size--){
     677        do{
     678            x= best[0];
     679            y= best[1];
     680            for(i=0; i<6; i++){
     681                CHECK_CLIPPED_MV(x+hex[i][0]*dia_size, y+hex[i][1]*dia_size);
     682            }
     683        }while(best[0] != x || best[1] != y);
     684    }
     685
     686    do{
     687        x= best[0];
     688        y= best[1];
     689        CHECK_CLIPPED_MV(x+1, y);
     690        CHECK_CLIPPED_MV(x, y+1);
     691        CHECK_CLIPPED_MV(x-1, y);
     692        CHECK_CLIPPED_MV(x, y-1);
     693    }while(best[0] != x || best[1] != y);
     694
     695    return dmin;
     696}
     697
     698static int l2s_dia_search(MpegEncContext * s, int *best, int dmin,
     699                                       int src_index, int ref_index, int const penalty_factor,
     700                                       int size, int h, int flags)
     701{
     702    MotionEstContext * const c= &s->me;
     703    me_cmp_func cmpf, chroma_cmpf;
     704    LOAD_COMMON
     705    LOAD_COMMON2
     706    int map_generation= c->map_generation;
     707    int x,y,i,d, dia_size;
     708    static const int hex[8][2]={{-2, 0}, {-1,-1}, { 0,-2}, { 1,-1},
     709                                { 2, 0}, { 1, 1}, { 0, 2}, {-1, 1}};
     710
     711    cmpf= s->dsp.me_cmp[size];
     712    chroma_cmpf= s->dsp.me_cmp[size+1];
     713
     714    for(dia_size= c->dia_size&0xFF; dia_size; dia_size--){
     715        do{
     716            x= best[0];
     717            y= best[1];
     718            for(i=0; i<8; i++){
     719                CHECK_CLIPPED_MV(x+hex[i][0]*dia_size, y+hex[i][1]*dia_size);
     720            }
     721        }while(best[0] != x || best[1] != y);
     722    }
     723
     724    x= best[0];
     725    y= best[1];
     726    CHECK_CLIPPED_MV(x+1, y);
     727    CHECK_CLIPPED_MV(x, y+1);
     728    CHECK_CLIPPED_MV(x-1, y);
     729    CHECK_CLIPPED_MV(x, y-1);
     730
     731    return dmin;
     732}
     733
     734static int umh_search(MpegEncContext * s, int *best, int dmin,
     735                                       int src_index, int ref_index, int const penalty_factor,
     736                                       int size, int h, int flags)
     737{
     738    MotionEstContext * const c= &s->me;
     739    me_cmp_func cmpf, chroma_cmpf;
     740    LOAD_COMMON
     741    LOAD_COMMON2
     742    int map_generation= c->map_generation;
     743    int x,y,x2,y2, i, j, d;
     744    const int dia_size= c->dia_size&0xFE;
     745    static const int hex[16][2]={{-4,-2}, {-4,-1}, {-4, 0}, {-4, 1}, {-4, 2},
     746                                 { 4,-2}, { 4,-1}, { 4, 0}, { 4, 1}, { 4, 2},
     747                                 {-2, 3}, { 0, 4}, { 2, 3},
     748                                 {-2,-3}, { 0,-4}, { 2,-3},};
     749
     750    cmpf= s->dsp.me_cmp[size];
     751    chroma_cmpf= s->dsp.me_cmp[size+1];
     752
     753    x= best[0];
     754    y= best[1];
     755    for(x2=FFMAX(x-dia_size+1, xmin); x2<=FFMIN(x+dia_size-1,xmax); x2+=2){
     756        CHECK_MV(x2, y);
     757    }
     758    for(y2=FFMAX(y-dia_size/2+1, ymin); y2<=FFMIN(y+dia_size/2-1,ymax); y2+=2){
     759        CHECK_MV(x, y2);
     760    }
     761
     762    x= best[0];
     763    y= best[1];
     764    for(y2=FFMAX(y-2, ymin); y2<=FFMIN(y+2,ymax); y2++){
     765        for(x2=FFMAX(x-2, xmin); x2<=FFMIN(x+2,xmax); x2++){
     766            CHECK_MV(x2, y2);
     767        }
     768    }
     769
     770//FIXME prevent the CLIP stuff
     771
     772    for(j=1; j<=dia_size/4; j++){
     773        for(i=0; i<16; i++){
     774            CHECK_CLIPPED_MV(x+hex[i][0]*j, y+hex[i][1]*j);
     775        }
     776    }
     777
     778    return hex_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags, 1);
    659779}
    660780
    … …  
    856976    else if(c->dia_size<2)
    857977        return small_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
     978    else if(c->dia_size>768)
     979        return           umh_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
     980    else if(c->dia_size>512)
     981        return           hex_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags, c->dia_size&0xFF);
     982    else if(c->dia_size>256)
     983        return       l2s_dia_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
    858984    else
    859985        return   var_diamond_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags);
    … …  
    8961022    if (s->first_slice_line) {
    8971023        CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
    898         CHECK_CLIPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
     1024        CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
    8991025                        (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
    9001026    }else{
    … …  
    9081034            return dmin;
    9091035        }
    910         CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift)
    911         if(dmin>h*h*2){
    912             CHECK_CLIPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
    913                             (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
    914             CHECK_MV(P_LEFT[0]    >>shift, P_LEFT[1]    >>shift)
    915             CHECK_MV(P_TOP[0]     >>shift, P_TOP[1]     >>shift)
    916             CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift)
    917         }
     1036        CHECK_MV(    P_MEDIAN[0] >>shift ,    P_MEDIAN[1] >>shift)
     1037        CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift)  , (P_MEDIAN[1]>>shift)-1)
     1038        CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift)  , (P_MEDIAN[1]>>shift)+1)
     1039        CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift)-1, (P_MEDIAN[1]>>shift)  )
     1040        CHECK_CLIPPED_MV((P_MEDIAN[0]>>shift)+1, (P_MEDIAN[1]>>shift)  )
     1041        CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
     1042                        (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
     1043        CHECK_MV(P_LEFT[0]    >>shift, P_LEFT[1]    >>shift)
     1044        CHECK_MV(P_TOP[0]     >>shift, P_TOP[1]     >>shift)
     1045        CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift)
    9181046    }
    9191047    if(dmin>h*h*4){
    9201048        if(c->pre_pass){
    921             CHECK_CLIPED_MV((last_mv[ref_mv_xy-1][0]*ref_mv_scale + (1<<15))>>16,
     1049            CHECK_CLIPPED_MV((last_mv[ref_mv_xy-1][0]*ref_mv_scale + (1<<15))>>16,
    9221050                            (last_mv[ref_mv_xy-1][1]*ref_mv_scale + (1<<15))>>16)
    9231051            if(!s->first_slice_line)
    924                 CHECK_CLIPED_MV((last_mv[ref_mv_xy-ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
     1052                CHECK_CLIPPED_MV((last_mv[ref_mv_xy-ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
    9251053                                (last_mv[ref_mv_xy-ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
    9261054        }else{
    927             CHECK_CLIPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16,
     1055            CHECK_CLIPPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16,
    9281056                            (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16)
    9291057            if(s->mb_y+1<s->end_mb_y)  //FIXME replace at least with last_slice_line
    930                 CHECK_CLIPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
     1058                CHECK_CLIPPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
    9311059                                (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
    9321060        }
    … …  
    10101138    if (s->first_slice_line) {
    10111139        CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
    1012         CHECK_CLIPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
     1140        CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
    10131141                        (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
    10141142        CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift)
    … …  
    10161144        CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift)
    10171145        //FIXME try some early stop
    1018         if(dmin>64*2){
    1019             CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift)
    1020             CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
    1021             CHECK_MV(P_TOP[0]>>shift, P_TOP[1]>>shift)
    1022             CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift)
    1023             CHECK_CLIPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
    1024                             (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
    1025         }
     1146        CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift)
     1147        CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
     1148        CHECK_MV(P_TOP[0]>>shift, P_TOP[1]>>shift)
     1149        CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift)
     1150        CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
     1151                        (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
    10261152    }
    10271153    if(dmin>64*4){
    1028         CHECK_CLIPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16,
     1154        CHECK_CLIPPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16,
    10291155                        (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16)
    10301156        if(s->mb_y+1<s->end_mb_y)  //FIXME replace at least with last_slice_line
    1031             CHECK_CLIPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
     1157            CHECK_CLIPPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
    10321158                            (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
    10331159    }
    … …  
    10721198    if (s->first_slice_line) {
    10731199        CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
    1074         CHECK_CLIPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
     1200        CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
    10751201                        (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
    10761202        CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift)
    … …  
    10781204        CHECK_MV(P_MV1[0]>>shift, P_MV1[1]>>shift)
    10791205        //FIXME try some early stop
    1080         if(dmin>64*2){
    1081             CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift)
    1082             CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
    1083             CHECK_MV(P_TOP[0]>>shift, P_TOP[1]>>shift)
    1084             CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift)
    1085             CHECK_CLIPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
    1086                             (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
    1087         }
     1206        CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift)
     1207        CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
     1208        CHECK_MV(P_TOP[0]>>shift, P_TOP[1]>>shift)
     1209        CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift)
     1210        CHECK_CLIPPED_MV((last_mv[ref_mv_xy][0]*ref_mv_scale + (1<<15))>>16,
     1211                        (last_mv[ref_mv_xy][1]*ref_mv_scale + (1<<15))>>16)
    10881212    }
    10891213    if(dmin>64*4){
    1090         CHECK_CLIPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16,
     1214        CHECK_CLIPPED_MV((last_mv[ref_mv_xy+1][0]*ref_mv_scale + (1<<15))>>16,
    10911215                        (last_mv[ref_mv_xy+1][1]*ref_mv_scale + (1<<15))>>16)
    10921216        if(s->mb_y+1<s->end_mb_y)  //FIXME replace at least with last_slice_line
    1093             CHECK_CLIPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
     1217            CHECK_CLIPPED_MV((last_mv[ref_mv_xy+ref_mv_stride][0]*ref_mv_scale + (1<<15))>>16,
    10941218                            (last_mv[ref_mv_xy+ref_mv_stride][1]*ref_mv_scale + (1<<15))>>16)
    10951219    }

  • TabularUnified trunk/libavcodec/mpegvideo.c

    r263 r269  
    25572557                if(s->adaptive_quant){
    25582558                    int i;
    2559                     for(i=0; i<s->mb_height*s->mb_width; i++)
     2559                    for(i=0; i<s->mb_height*s->mb_stride; i++)
    25602560                        s->lambda_table[i]= FFMAX(s->lambda_table[i]+1, s->lambda_table[i]*(s->qscale+1) / s->qscale);
    25612561                }
    … …  
    39353935        s->mbintra_table[mb_xy]=1;
    39363936
    3937     if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
     3937    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
    39383938        uint8_t *dest_y, *dest_cb, *dest_cr;
    39393939        int dct_linesize, dct_offset;

  • TabularUnified trunk/libavcodec/shorten.c

    r256 r269  
    336336        s->nwrap = FFMAX(NWRAP, maxnlpc);
    337337
    338         allocate_buffers(s);
     338        if (allocate_buffers(s))
     339            return -1;
    339340
    340341        init_offset(s);

  • TabularUnified trunk/libavcodec/svq1.c

    r256 r269  
    906906
    907907        /* output 5 unknown bits (2 + 2 + 1) */
    908         put_bits(&s->pb, 5, 0);
     908        put_bits(&s->pb, 5, 2); /* 2 needed by quicktime decoder */
    909909
    910910        for (i = 0; i < 7; i++)
    … …  
    13561356
    13571357    *p = *pict;
    1358     p->pict_type = avctx->frame_number % avctx->gop_size ? P_TYPE : I_TYPE;
     1358    p->pict_type = avctx->gop_size && avctx->frame_number % avctx->gop_size ? P_TYPE : I_TYPE;
    13591359    p->key_frame = p->pict_type == I_TYPE;
    13601360

  • TabularUnified trunk/libavcodec/utils.c

    r263 r269  
    480480{"bf", "use 'frames' B frames", OFFSET(max_b_frames), FF_OPT_TYPE_INT, DEFAULT, 0, FF_MAX_B_FRAMES, V|E},
    481481{"b_qfactor", "qp factor between p and b frames", OFFSET(b_quant_factor), FF_OPT_TYPE_FLOAT, 1.25, FLT_MIN, FLT_MAX, V|E},
    482 {"rc_strategy", NULL, OFFSET(rc_strategy), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
    483 {"b_strategy", NULL, OFFSET(b_frame_strategy), FF_OPT_TYPE_INT, 0, INT_MIN, INT_MAX, V|E},
     482{"rc_strategy", "ratecontrol method", OFFSET(rc_strategy), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
     483{"b_strategy", "strategy to choose between I/P/B-frames", OFFSET(b_frame_strategy), FF_OPT_TYPE_INT, 0, INT_MIN, INT_MAX, V|E},
    484484{"hurry_up", NULL, OFFSET(hurry_up), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|D},
    485485{"rtp_mode", NULL, OFFSET(rtp_mode), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX},
    … …  
    497497{"bug", "workaround not auto detected encoder bugs", OFFSET(workaround_bugs), FF_OPT_TYPE_FLAGS, FF_BUG_AUTODETECT, INT_MIN, INT_MAX, V|D, "bug"},
    498498{"autodetect", NULL, 0, FF_OPT_TYPE_CONST, FF_BUG_AUTODETECT, INT_MIN, INT_MAX, V|D, "bug"},
    499 {"old_msmpeg4", NULL, 0, FF_OPT_TYPE_CONST, FF_BUG_OLD_MSMPEG4, INT_MIN, INT_MAX, V|D, "bug"},
    500 {"xvid_ilace", NULL, 0, FF_OPT_TYPE_CONST, FF_BUG_XVID_ILACE, INT_MIN, INT_MAX, V|D, "bug"},
    501 {"ump4", NULL, 0, FF_OPT_TYPE_CONST, FF_BUG_UMP4, INT_MIN, INT_MAX, V|D, "bug"},
    502 {"no_padding", NULL, 0, FF_OPT_TYPE_CONST, FF_BUG_NO_PADDING, INT_MIN, INT_MAX, V|D, "bug"},
     499{"old_msmpeg4", "some old lavc generated msmpeg4v3 files (no autodetection)", 0, FF_OPT_TYPE_CONST, FF_BUG_OLD_MSMPEG4, INT_MIN, INT_MAX, V|D, "bug"},
     500{"xvid_ilace", "Xvid interlacing bug (autodetected if fourcc==XVIX)", 0, FF_OPT_TYPE_CONST, FF_BUG_XVID_ILACE, INT_MIN, INT_MAX, V|D, "bug"},
     501{"ump4", "(autodetected if fourcc==UMP4)", 0, FF_OPT_TYPE_CONST, FF_BUG_UMP4, INT_MIN, INT_MAX, V|D, "bug"},
     502{"no_padding", "padding bug (autodetected)", 0, FF_OPT_TYPE_CONST, FF_BUG_NO_PADDING, INT_MIN, INT_MAX, V|D, "bug"},
    503503{"amv", NULL, 0, FF_OPT_TYPE_CONST, FF_BUG_AMV, INT_MIN, INT_MAX, V|D, "bug"},
    504 {"ac_vlc", NULL, 0, FF_OPT_TYPE_CONST, FF_BUG_AC_VLC, INT_MIN, INT_MAX, V|D, "bug"},
     504{"ac_vlc", "illegal vlc bug (autodetected per fourcc)", 0, FF_OPT_TYPE_CONST, FF_BUG_AC_VLC, INT_MIN, INT_MAX, V|D, "bug"},
    505505{"qpel_chroma", NULL, 0, FF_OPT_TYPE_CONST, FF_BUG_QPEL_CHROMA, INT_MIN, INT_MAX, V|D, "bug"},
    506 {"std_qpel", NULL, 0, FF_OPT_TYPE_CONST, FF_BUG_STD_QPEL, INT_MIN, INT_MAX, V|D, "bug"},
     506{"std_qpel", "old standard qpel (autodetected per fourcc/version)", 0, FF_OPT_TYPE_CONST, FF_BUG_STD_QPEL, INT_MIN, INT_MAX, V|D, "bug"},
    507507{"qpel_chroma2", NULL, 0, FF_OPT_TYPE_CONST, FF_BUG_QPEL_CHROMA2, INT_MIN, INT_MAX, V|D, "bug"},
    508 {"direct_blocksize", NULL, 0, FF_OPT_TYPE_CONST, FF_BUG_DIRECT_BLOCKSIZE, INT_MIN, INT_MAX, V|D, "bug"},
    509 {"edge", NULL, 0, FF_OPT_TYPE_CONST, FF_BUG_EDGE, INT_MIN, INT_MAX, V|D, "bug"},
     508{"direct_blocksize", "direct-qpel-blocksize bug (autodetected per fourcc/version)", 0, FF_OPT_TYPE_CONST, FF_BUG_DIRECT_BLOCKSIZE, INT_MIN, INT_MAX, V|D, "bug"},
     509{"edge", "edge padding bug (autodetected per fourcc/version)", 0, FF_OPT_TYPE_CONST, FF_BUG_EDGE, INT_MIN, INT_MAX, V|D, "bug"},
    510510{"hpel_chroma", NULL, 0, FF_OPT_TYPE_CONST, FF_BUG_HPEL_CHROMA, INT_MIN, INT_MAX, V|D, "bug"},
    511511{"dc_clip", NULL, 0, FF_OPT_TYPE_CONST, FF_BUG_DC_CLIP, INT_MIN, INT_MAX, V|D, "bug"},
    … …  
    520520{"experimental", NULL, 0, FF_OPT_TYPE_CONST, FF_COMPLIANCE_EXPERIMENTAL, INT_MIN, INT_MAX, V|E, "strict"},
    521521{"b_qoffset", "qp offset between p and b frames", OFFSET(b_quant_offset), FF_OPT_TYPE_FLOAT, 1.25, FLT_MIN, FLT_MAX, V|E},
    522 {"er", NULL, OFFSET(error_resilience), FF_OPT_TYPE_INT, FF_ER_CAREFUL, INT_MIN, INT_MAX, V|D, "er"},
     522{"er", "set error resilience strategy", OFFSET(error_resilience), FF_OPT_TYPE_INT, FF_ER_CAREFUL, INT_MIN, INT_MAX, V|D, "er"},
    523523{"careful", NULL, 0, FF_OPT_TYPE_CONST, FF_ER_CAREFUL, INT_MIN, INT_MAX, V|D, "er"},
    524524{"compliant", NULL, 0, FF_OPT_TYPE_CONST, FF_ER_COMPLIANT, INT_MIN, INT_MAX, V|D, "er"},
    … …  
    528528{"block_align", NULL, OFFSET(block_align), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX},
    529529{"parse_only", NULL, OFFSET(parse_only), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX},
    530 {"mpeg_quant", NULL, OFFSET(mpeg_quant), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
     530{"mpeg_quant", "use MPEG quantizers instead of H.263", OFFSET(mpeg_quant), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
    531531{"stats_out", NULL, OFFSET(stats_out), FF_OPT_TYPE_STRING, DEFAULT, CHAR_MIN, CHAR_MAX},
    532532{"stats_in", NULL, OFFSET(stats_in), FF_OPT_TYPE_STRING, DEFAULT, CHAR_MIN, CHAR_MAX},
    533533{"qsquish", "how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function)", OFFSET(rc_qsquish), FF_OPT_TYPE_FLOAT, DEFAULT, 0, 99, V|E},
    534 {"rc_qmod_amp", NULL, OFFSET(rc_qmod_amp), FF_OPT_TYPE_FLOAT, DEFAULT, -FLT_MAX, FLT_MAX, V|E},
    535 {"rc_qmod_freq", NULL, OFFSET(rc_qmod_freq), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
     534{"rc_qmod_amp", "experimental quantizer modulation", OFFSET(rc_qmod_amp), FF_OPT_TYPE_FLOAT, DEFAULT, -FLT_MAX, FLT_MAX, V|E},
     535{"rc_qmod_freq", "experimental quantizer modulation", OFFSET(rc_qmod_freq), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
    536536{"rc_override_count", NULL, OFFSET(rc_override_count), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX},
    537537{"rc_eq", "set rate control equation", OFFSET(rc_eq), FF_OPT_TYPE_STRING, DEFAULT, CHAR_MIN, CHAR_MAX, V|E},
    … …  
    539539{"minrate", "set min video bitrate tolerance (in bits/s)", OFFSET(rc_min_rate), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
    540540{"bufsize", "set ratecontrol buffer size (in bits)", OFFSET(rc_buffer_size), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
    541 {"rc_buf_aggressivity", NULL, OFFSET(rc_buffer_aggressivity), FF_OPT_TYPE_FLOAT, 1.0, FLT_MIN, FLT_MAX, V|E},
     541{"rc_buf_aggressivity", "currently useless", OFFSET(rc_buffer_aggressivity), FF_OPT_TYPE_FLOAT, 1.0, FLT_MIN, FLT_MAX, V|E},
    542542{"i_qfactor", "qp factor between p and i frames", OFFSET(i_quant_factor), FF_OPT_TYPE_FLOAT, -0.8, -FLT_MAX, FLT_MAX, V|E},
    543543{"i_qoffset", "qp offset between p and i frames", OFFSET(i_quant_offset), FF_OPT_TYPE_FLOAT, 0.0, -FLT_MAX, FLT_MAX, V|E},
    544544{"rc_init_cplx", "initial complexity for 1-pass encoding", OFFSET(rc_initial_cplx), FF_OPT_TYPE_FLOAT, DEFAULT, -FLT_MAX, FLT_MAX, V|E},
    545 {"dct", NULL, OFFSET(dct_algo), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, V|E, "dct"},
    546 {"auto", NULL, 0, FF_OPT_TYPE_CONST, FF_DCT_AUTO, INT_MIN, INT_MAX, V|E, "dct"},
    547 {"fastint", NULL, 0, FF_OPT_TYPE_CONST, FF_DCT_FASTINT, INT_MIN, INT_MAX, V|E, "dct"},
    548 {"int", NULL, 0, FF_OPT_TYPE_CONST, FF_DCT_INT, INT_MIN, INT_MAX, V|E, "dct"},
     545{"dct", "DCT algorithm", OFFSET(dct_algo), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, V|E, "dct"},
     546{"auto", "autoselect a good one (default)", 0, FF_OPT_TYPE_CONST, FF_DCT_AUTO, INT_MIN, INT_MAX, V|E, "dct"},
     547{"fastint", "fast integer", 0, FF_OPT_TYPE_CONST, FF_DCT_FASTINT, INT_MIN, INT_MAX, V|E, "dct"},
     548{"int", "accurate integer", 0, FF_OPT_TYPE_CONST, FF_DCT_INT, INT_MIN, INT_MAX, V|E, "dct"},
    549549{"mmx", NULL, 0, FF_OPT_TYPE_CONST, FF_DCT_MMX, INT_MIN, INT_MAX, V|E, "dct"},
    550550{"mlib", NULL, 0, FF_OPT_TYPE_CONST, FF_DCT_MLIB, INT_MIN, INT_MAX, V|E, "dct"},
    551551{"altivec", NULL, 0, FF_OPT_TYPE_CONST, FF_DCT_ALTIVEC, INT_MIN, INT_MAX, V|E, "dct"},
    552 {"faan", NULL, 0, FF_OPT_TYPE_CONST, FF_DCT_FAAN, INT_MIN, INT_MAX, V|E, "dct"},
    553 {"lumi_mask", "lumimasking", OFFSET(lumi_masking), FF_OPT_TYPE_FLOAT, 0, -FLT_MAX, FLT_MAX, V|E},
     552{"faan", "floating point AAN", 0, FF_OPT_TYPE_CONST, FF_DCT_FAAN, INT_MIN, INT_MAX, V|E, "dct"},
     553{"lumi_mask", "compresses bright areas stronger than medium ones", OFFSET(lumi_masking), FF_OPT_TYPE_FLOAT, 0, -FLT_MAX, FLT_MAX, V|E},
    554554{"tcplx_mask", "temporal complexity masking", OFFSET(temporal_cplx_masking), FF_OPT_TYPE_FLOAT, 0, -FLT_MAX, FLT_MAX, V|E},
    555555{"scplx_mask", "spatial complexity masking", OFFSET(spatial_cplx_masking), FF_OPT_TYPE_FLOAT, 0, -FLT_MAX, FLT_MAX, V|E},
    556556{"p_mask", "inter masking", OFFSET(p_masking), FF_OPT_TYPE_FLOAT, 0, -FLT_MAX, FLT_MAX, V|E},
    557 {"dark_mask", "darkness masking", OFFSET(dark_masking), FF_OPT_TYPE_FLOAT, 0, -FLT_MAX, FLT_MAX, V|E},
     557{"dark_mask", "compresses dark areas stronger than medium ones", OFFSET(dark_masking), FF_OPT_TYPE_FLOAT, 0, -FLT_MAX, FLT_MAX, V|E},
    558558{"unused", NULL, OFFSET(unused), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX},
    559 {"idct", NULL, OFFSET(idct_algo), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, V|E|D, "idct"},
     559{"idct", "use interlaced DCT", OFFSET(idct_algo), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, V|E|D, "idct"},
    560560{"auto", NULL, 0, FF_OPT_TYPE_CONST, FF_IDCT_AUTO, INT_MIN, INT_MAX, V|E|D, "idct"},
    561561{"int", NULL, 0, FF_OPT_TYPE_CONST, FF_IDCT_INT, INT_MIN, INT_MAX, V|E|D, "idct"},
    … …  
    575575{"xvidmmx", NULL, 0, FF_OPT_TYPE_CONST, FF_IDCT_XVIDMMX, INT_MIN, INT_MAX, V|E|D, "idct"},
    576576{"slice_count", NULL, OFFSET(slice_count), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX},
    577 {"ec", NULL, OFFSET(error_concealment), FF_OPT_TYPE_FLAGS, 3, INT_MIN, INT_MAX, V|D, "ec"},
    578 {"guess_mvs", NULL, 0, FF_OPT_TYPE_CONST, FF_EC_GUESS_MVS, INT_MIN, INT_MAX, V|D, "ec"},
    579 {"deblock", NULL, 0, FF_OPT_TYPE_CONST, FF_EC_DEBLOCK, INT_MIN, INT_MAX, V|D, "ec"},
     577{"ec", "set error concealment strategy", OFFSET(error_concealment), FF_OPT_TYPE_FLAGS, 3, INT_MIN, INT_MAX, V|D, "ec"},
     578{"guess_mvs", "iterative motion vector (MV) search (slow)", 0, FF_OPT_TYPE_CONST, FF_EC_GUESS_MVS, INT_MIN, INT_MAX, V|D, "ec"},
     579{"deblock", "use strong deblock filter for damaged MBs", 0, FF_OPT_TYPE_CONST, FF_EC_DEBLOCK, INT_MIN, INT_MAX, V|D, "ec"},
    580580{"bits_per_sample", NULL, OFFSET(bits_per_sample), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX},
    581581{"pred", "prediction method", OFFSET(prediction_method), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E, "pred"},
    … …  
    585585{"aspect", NULL, OFFSET(sample_aspect_ratio), FF_OPT_TYPE_RATIONAL, DEFAULT, 0, 10, V|E},
    586586{"debug", "print specific debug info", OFFSET(debug), FF_OPT_TYPE_FLAGS, DEFAULT, 0, INT_MAX, V|A|S|E|D, "debug"},
    587 {"pict", NULL, 0, FF_OPT_TYPE_CONST, FF_DEBUG_PICT_INFO, INT_MIN, INT_MAX, V|D, "debug"},
    588 {"rc", NULL, 0, FF_OPT_TYPE_CONST, FF_DEBUG_RC, INT_MIN, INT_MAX, V|E, "debug"},
     587{"pict", "picture info", 0, FF_OPT_TYPE_CONST, FF_DEBUG_PICT_INFO, INT_MIN, INT_MAX, V|D, "debug"},
     588{"rc", "rate control", 0, FF_OPT_TYPE_CONST, FF_DEBUG_RC, INT_MIN, INT_MAX, V|E, "debug"},
    589589{"bitstream", NULL, 0, FF_OPT_TYPE_CONST, FF_DEBUG_BITSTREAM, INT_MIN, INT_MAX, V|D, "debug"},
    590 {"mb_type", NULL, 0, FF_OPT_TYPE_CONST, FF_DEBUG_MB_TYPE, INT_MIN, INT_MAX, V|D, "debug"},
    591 {"qp", NULL, 0, FF_OPT_TYPE_CONST, FF_DEBUG_QP, INT_MIN, INT_MAX, V|D, "debug"},
    592 {"mv", NULL, 0, FF_OPT_TYPE_CONST, FF_DEBUG_MV, INT_MIN, INT_MAX, V|D, "debug"},
     590{"mb_type", "macroblock (MB) type", 0, FF_OPT_TYPE_CONST, FF_DEBUG_MB_TYPE, INT_MIN, INT_MAX, V|D, "debug"},
     591{"qp", "per-block quantization parameter (QP)", 0, FF_OPT_TYPE_CONST, FF_DEBUG_QP, INT_MIN, INT_MAX, V|D, "debug"},
     592{"mv", "motion vector", 0, FF_OPT_TYPE_CONST, FF_DEBUG_MV, INT_MIN, INT_MAX, V|D, "debug"},
    593593{"dct_coeff", NULL, 0, FF_OPT_TYPE_CONST, FF_DEBUG_DCT_COEFF, INT_MIN, INT_MAX, V|D, "debug"},
    594594{"skip", NULL, 0, FF_OPT_TYPE_CONST, FF_DEBUG_SKIP, INT_MIN, INT_MAX, V|D, "debug"},
    595595{"startcode", NULL, 0, FF_OPT_TYPE_CONST, FF_DEBUG_STARTCODE, INT_MIN, INT_MAX, V|D, "debug"},
    596596{"pts", NULL, 0, FF_OPT_TYPE_CONST, FF_DEBUG_PTS, INT_MIN, INT_MAX, V|D, "debug"},
    597 {"er", NULL, 0, FF_OPT_TYPE_CONST, FF_DEBUG_ER, INT_MIN, INT_MAX, V|D, "debug"},
    598 {"mmco", NULL, 0, FF_OPT_TYPE_CONST, FF_DEBUG_MMCO, INT_MIN, INT_MAX, V|D, "debug"},
     597{"er", "error resilience", 0, FF_OPT_TYPE_CONST, FF_DEBUG_ER, INT_MIN, INT_MAX, V|D, "debug"},
     598{"mmco", "memory management control operations (H.264)", 0, FF_OPT_TYPE_CONST, FF_DEBUG_MMCO, INT_MIN, INT_MAX, V|D, "debug"},
    599599{"bugs", NULL, 0, FF_OPT_TYPE_CONST, FF_DEBUG_BUGS, INT_MIN, INT_MAX, V|D, "debug"},
    600 {"vis_qp", NULL, 0, FF_OPT_TYPE_CONST, FF_DEBUG_VIS_QP, INT_MIN, INT_MAX, V|D, "debug"},
    601 {"vis_mb_type", NULL, 0, FF_OPT_TYPE_CONST, FF_DEBUG_VIS_MB_TYPE, INT_MIN, INT_MAX, V|D, "debug"},
    602 {"vismv", "visualize motion vectors", OFFSET(debug_mv), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, V|D, "debug_mv"},
    603 {"pf", NULL, 0, FF_OPT_TYPE_CONST, FF_DEBUG_VIS_MV_P_FOR, INT_MIN, INT_MAX, V|D, "debug_mv"},
    604 {"bf", NULL, 0, FF_OPT_TYPE_CONST, FF_DEBUG_VIS_MV_B_FOR, INT_MIN, INT_MAX, V|D, "debug_mv"},
    605 {"bb", NULL, 0, FF_OPT_TYPE_CONST, FF_DEBUG_VIS_MV_B_BACK, INT_MIN, INT_MAX, V|D, "debug_mv"},
    606 {"mb_qmin", NULL, OFFSET(mb_qmin), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
    607 {"mb_qmax", NULL, OFFSET(mb_qmax), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
     600{"vis_qp", "visualize quantization parameter (QP), lower QP are tinted greener", 0, FF_OPT_TYPE_CONST, FF_DEBUG_VIS_QP, INT_MIN, INT_MAX, V|D, "debug"},
     601{"vis_mb_type", "visualize block types", 0, FF_OPT_TYPE_CONST, FF_DEBUG_VIS_MB_TYPE, INT_MIN, INT_MAX, V|D, "debug"},
     602{"vismv", "visualize motion vectors (MVs)", OFFSET(debug_mv), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, V|D, "debug_mv"},
     603{"pf", "forward predicted MVs of P-frames", 0, FF_OPT_TYPE_CONST, FF_DEBUG_VIS_MV_P_FOR, INT_MIN, INT_MAX, V|D, "debug_mv"},
     604{"bf", "forward predicted MVs of B-frames", 0, FF_OPT_TYPE_CONST, FF_DEBUG_VIS_MV_B_FOR, INT_MIN, INT_MAX, V|D, "debug_mv"},
     605{"bb", "backward predicted MVs of B-frames", 0, FF_OPT_TYPE_CONST, FF_DEBUG_VIS_MV_B_BACK, INT_MIN, INT_MAX, V|D, "debug_mv"},
     606{"mb_qmin", "obsolete, use vqmin", OFFSET(mb_qmin), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
     607{"mb_qmax", "obsolete, use vqmax", OFFSET(mb_qmax), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
    608608{"cmp", "full pel me compare function", OFFSET(me_cmp), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E, "cmp_func"},
    609609{"subcmp", "sub pel me compare function", OFFSET(me_sub_cmp), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E, "cmp_func"},
    610610{"mbcmp", "macroblock compare function", OFFSET(mb_cmp), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E, "cmp_func"},
    611611{"ildctcmp", "interlaced dct compare function", OFFSET(ildct_cmp), FF_OPT_TYPE_INT, FF_CMP_VSAD, INT_MIN, INT_MAX, V|E, "cmp_func"},
    612 {"dia_size", NULL, OFFSET(dia_size), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
    613 {"last_pred", NULL, OFFSET(last_predictor_count), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
     612{"dia_size", "diamond type & size for motion estimation", OFFSET(dia_size), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
     613{"last_pred", "amount of motion predictors from the previous frame", OFFSET(last_predictor_count), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
    614614{"preme", "pre motion estimation", OFFSET(pre_me), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
    615615{"precmp", "pre motion estimation compare function", OFFSET(me_pre_cmp), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E, "cmp_func"},
    616 {"sad", NULL, 0, FF_OPT_TYPE_CONST, FF_CMP_SAD, INT_MIN, INT_MAX, V|E, "cmp_func"},
    617 {"sse", NULL, 0, FF_OPT_TYPE_CONST, FF_CMP_SSE, INT_MIN, INT_MAX, V|E, "cmp_func"},
    618 {"satd", NULL, 0, FF_OPT_TYPE_CONST, FF_CMP_SATD, INT_MIN, INT_MAX, V|E, "cmp_func"},
    619 {"dct", NULL, 0, FF_OPT_TYPE_CONST, FF_CMP_DCT, INT_MIN, INT_MAX, V|E, "cmp_func"},
    620 {"psnr", NULL, 0, FF_OPT_TYPE_CONST, FF_CMP_PSNR, INT_MIN, INT_MAX, V|E, "cmp_func"},
    621 {"bit", NULL, 0, FF_OPT_TYPE_CONST, FF_CMP_BIT, INT_MIN, INT_MAX, V|E, "cmp_func"},
    622 {"rd", NULL, 0, FF_OPT_TYPE_CONST, FF_CMP_RD, INT_MIN, INT_MAX, V|E, "cmp_func"},
    623 {"zero", NULL, 0, FF_OPT_TYPE_CONST, FF_CMP_ZERO, INT_MIN, INT_MAX, V|E, "cmp_func"},
    624 {"vsad", NULL, 0, FF_OPT_TYPE_CONST, FF_CMP_VSAD, INT_MIN, INT_MAX, V|E, "cmp_func"},
    625 {"vsse", NULL, 0, FF_OPT_TYPE_CONST, FF_CMP_VSSE, INT_MIN, INT_MAX, V|E, "cmp_func"},
    626 {"nsse", NULL, 0, FF_OPT_TYPE_CONST, FF_CMP_NSSE, INT_MIN, INT_MAX, V|E, "cmp_func"},
     616{"sad", "sum of absolute differences, fast (default)", 0, FF_OPT_TYPE_CONST, FF_CMP_SAD, INT_MIN, INT_MAX, V|E, "cmp_func"},
     617{"sse", "sum of squared errors", 0, FF_OPT_TYPE_CONST, FF_CMP_SSE, INT_MIN, INT_MAX, V|E, "cmp_func"},
     618{"satd", "sum of absolute Hadamard transformed differences", 0, FF_OPT_TYPE_CONST, FF_CMP_SATD, INT_MIN, INT_MAX, V|E, "cmp_func"},
     619{"dct", "sum of absolute DCT transformed differences", 0, FF_OPT_TYPE_CONST, FF_CMP_DCT, INT_MIN, INT_MAX, V|E, "cmp_func"},
     620{"psnr", "sum of squared quantization errors (avoid, low quality)", 0, FF_OPT_TYPE_CONST, FF_CMP_PSNR, INT_MIN, INT_MAX, V|E, "cmp_func"},
     621{"bit", "number of bits needed for the block", 0, FF_OPT_TYPE_CONST, FF_CMP_BIT, INT_MIN, INT_MAX, V|E, "cmp_func"},
     622{"rd", "rate distortion optimal, slow", 0, FF_OPT_TYPE_CONST, FF_CMP_RD, INT_MIN, INT_MAX, V|E, "cmp_func"},
     623{"zero", "0", 0, FF_OPT_TYPE_CONST, FF_CMP_ZERO, INT_MIN, INT_MAX, V|E, "cmp_func"},
     624{"vsad", "sum of absolute vertical differences", 0, FF_OPT_TYPE_CONST, FF_CMP_VSAD, INT_MIN, INT_MAX, V|E, "cmp_func"},
     625{"vsse","sum of squared vertical differences", 0, FF_OPT_TYPE_CONST, FF_CMP_VSSE, INT_MIN, INT_MAX, V|E, "cmp_func"},
     626{"nsse", "noise preserving sum of squared differences", 0, FF_OPT_TYPE_CONST, FF_CMP_NSSE, INT_MIN, INT_MAX, V|E, "cmp_func"},
    627627#ifdef CONFIG_SNOW_ENCODER
    628 {"w53", NULL, 0, FF_OPT_TYPE_CONST, FF_CMP_W53, INT_MIN, INT_MAX, V|E, "cmp_func"},
    629 {"w97", NULL, 0, FF_OPT_TYPE_CONST, FF_CMP_W97, INT_MIN, INT_MAX, V|E, "cmp_func"},
     628{"w53", "5/3 wavelet, only used in snow", 0, FF_OPT_TYPE_CONST, FF_CMP_W53, INT_MIN, INT_MAX, V|E, "cmp_func"},
     629{"w97", "9/7 wavelet, only used in snow", 0, FF_OPT_TYPE_CONST, FF_CMP_W97, INT_MIN, INT_MAX, V|E, "cmp_func"},
    630630#endif
    631631{"dctmax", NULL, 0, FF_OPT_TYPE_CONST, FF_CMP_DCTMAX, INT_MIN, INT_MAX, V|E, "cmp_func"},
    632632{"chroma", NULL, 0, FF_OPT_TYPE_CONST, FF_CMP_CHROMA, INT_MIN, INT_MAX, V|E, "cmp_func"},
    633 {"pre_dia_size", NULL, OFFSET(pre_dia_size), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
     633{"pre_dia_size", "diamond type & size for motion estimation pre-pass", OFFSET(pre_dia_size), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
    634634{"subq", "sub pel motion estimation quality", OFFSET(me_subpel_quality), FF_OPT_TYPE_INT, 8, INT_MIN, INT_MAX, V|E},
    635635{"dtg_active_format", NULL, OFFSET(dtg_active_format), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX},
    … …  
    646646{"slice_flags", NULL, OFFSET(slice_flags), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX},
    647647{"xvmc_acceleration", NULL, OFFSET(xvmc_acceleration), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX},
    648 {"mbd", NULL, OFFSET(mb_decision), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E, "mbd"},
    649 {"simple", NULL, 0, FF_OPT_TYPE_CONST, FF_MB_DECISION_SIMPLE, INT_MIN, INT_MAX, V|E, "mbd"},
    650 {"bits", NULL, 0, FF_OPT_TYPE_CONST, FF_MB_DECISION_BITS, INT_MIN, INT_MAX, V|E, "mbd"},
    651 {"rd", NULL, 0, FF_OPT_TYPE_CONST, FF_MB_DECISION_RD, INT_MIN, INT_MAX, V|E, "mbd"},
     648{"mbd", "macroblock decision algorithm (high quality mode)", OFFSET(mb_decision), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E, "mbd"},
     649{"simple", "use mbcmp (default)", 0, FF_OPT_TYPE_CONST, FF_MB_DECISION_SIMPLE, INT_MIN, INT_MAX, V|E, "mbd"},
     650{"bits", "use fewest bits", 0, FF_OPT_TYPE_CONST, FF_MB_DECISION_BITS, INT_MIN, INT_MAX, V|E, "mbd"},
     651{"rd", "use best rate distortion", 0, FF_OPT_TYPE_CONST, FF_MB_DECISION_RD, INT_MIN, INT_MAX, V|E, "mbd"},
    652652{"stream_codec_tag", NULL, OFFSET(stream_codec_tag), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX},
    653653{"sc_threshold", "scene change threshold", OFFSET(scenechange_threshold), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
    … …  
    676676{"level", NULL, OFFSET(level), FF_OPT_TYPE_INT, FF_LEVEL_UNKNOWN, INT_MIN, INT_MAX, V|A|E, "level"},
    677677{"unknown", NULL, 0, FF_OPT_TYPE_CONST, FF_LEVEL_UNKNOWN, INT_MIN, INT_MAX, V|A|E, "level"},
    678 {"lowres", NULL, OFFSET(lowres), FF_OPT_TYPE_INT, 0, 0, INT_MAX, V|D},
     678{"lowres", "decode at 1= 1/2, 2=1/4, 3=1/8 resolutions", OFFSET(lowres), FF_OPT_TYPE_INT, 0, 0, INT_MAX, V|D},
    679679{"skip_threshold", "frame skip threshold", OFFSET(frame_skip_threshold), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
    680680{"skip_factor", "frame skip factor", OFFSET(frame_skip_factor), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
    681681{"skip_exp", "frame skip exponent", OFFSET(frame_skip_exp), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
    682682{"skipcmp", "frame skip compare function", OFFSET(frame_skip_cmp), FF_OPT_TYPE_INT, FF_CMP_DCTMAX, INT_MIN, INT_MAX, V|E, "cmp_func"},
    683 {"border_mask", NULL, OFFSET(border_masking), FF_OPT_TYPE_FLOAT, DEFAULT, -FLT_MAX, FLT_MAX, V|E},
     683{"border_mask", "increases the quantizer for macroblocks close to borders", OFFSET(border_masking), FF_OPT_TYPE_FLOAT, DEFAULT, -FLT_MAX, FLT_MAX, V|E},
    684684{"mblmin", "min macroblock lagrange factor (VBR)", OFFSET(mb_lmin), FF_OPT_TYPE_INT, FF_QP2LAMBDA * 2, 1, FF_LAMBDA_MAX, V|E},
    685685{"mblmax", "max macroblock lagrange factor (VBR)", OFFSET(mb_lmax), FF_OPT_TYPE_INT, FF_QP2LAMBDA * 31, 1, FF_LAMBDA_MAX, V|E},
    686686{"mepc", "motion estimation bitrate penalty compensation (1.0 = 256)", OFFSET(me_penalty_compensation), FF_OPT_TYPE_INT, 256, INT_MIN, INT_MAX, V|E},
    687 {"bidir_refine", NULL, OFFSET(bidir_refine), FF_OPT_TYPE_INT, DEFAULT, 0, 4, V|E},
    688 {"brd_scale", NULL, OFFSET(brd_scale), FF_OPT_TYPE_INT, DEFAULT, 0, 10, V|E},
    689 {"crf", NULL, OFFSET(crf), FF_OPT_TYPE_FLOAT, DEFAULT, 0, 51, V|E},
     687{"bidir_refine", "refine the two motion vectors used in bidirectional macroblocks", OFFSET(bidir_refine), FF_OPT_TYPE_INT, DEFAULT, 0, 4, V|E},
     688{"brd_scale", "downscales frames for dynamic B-frame decision", OFFSET(brd_scale), FF_OPT_TYPE_INT, DEFAULT, 0, 10, V|E},
     689{"crf", "enables constant quality mode, and selects the quality (x264)", OFFSET(crf), FF_OPT_TYPE_FLOAT, DEFAULT, 0, 51, V|E},
    690690{"cqp", NULL, OFFSET(cqp), FF_OPT_TYPE_INT, -1, INT_MIN, INT_MAX, V|E},
    691 {"keyint_min", NULL, OFFSET(keyint_min), FF_OPT_TYPE_INT, 25, INT_MIN, INT_MAX, V|E},
    692 {"refs", NULL, OFFSET(refs), FF_OPT_TYPE_INT, 1, INT_MIN, INT_MAX, V|E},
     691{"keyint_min", "minimum interval between IDR-frames (x264)", OFFSET(keyint_min), FF_OPT_TYPE_INT, 25, INT_MIN, INT_MAX, V|E},
     692{"refs", "reference frames to consider for motion compensation (Snow)", OFFSET(refs), FF_OPT_TYPE_INT, 1, INT_MIN, INT_MAX, V|E},
    693693{"chromaoffset", NULL, OFFSET(chromaoffset), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
    694694{"bframebias", NULL, OFFSET(bframebias), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
    695 {"trellis", NULL, OFFSET(trellis), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|A|E},
     695{"trellis", "rate-distortion optimal quantization", OFFSET(trellis), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|A|E},
    696696{"directpred", NULL, OFFSET(directpred), FF_OPT_TYPE_INT, 2, INT_MIN, INT_MAX, V|E},
    697 {"bpyramid", NULL, 0, FF_OPT_TYPE_CONST, CODEC_FLAG2_BPYRAMID, INT_MIN, INT_MAX, V|E, "flags2"},
     697{"bpyramid", "allows B-frames to be used as references for predicting", 0, FF_OPT_TYPE_CONST, CODEC_FLAG2_BPYRAMID, INT_MIN, INT_MAX, V|E, "flags2"},
    698698{"wpred", NULL, 0, FF_OPT_TYPE_CONST, CODEC_FLAG2_WPRED, INT_MIN, INT_MAX, V|E, "flags2"},
    699699{"mixed_refs", NULL, 0, FF_OPT_TYPE_CONST, CODEC_FLAG2_MIXED_REFS, INT_MIN, INT_MAX, V|E, "flags2"},

  • TabularUnified trunk/libavcodec/vc1.c

    r263 r269  
    791791    uvmx = (mx + ((mx & 3) == 3)) >> 1;
    792792    uvmy = (my + ((my & 3) == 3)) >> 1;
     793    if(v->fastuvmc) {
     794        uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
     795        uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
     796    }
    793797    if(!dir) {
    794798        srcY = s->last_picture.data[0];
    … …  
    877881        }
    878882        srcY += s->mspel * (1 + s->linesize);
    879     }
    880 
    881     if(v->fastuvmc) {
    882         uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
    883         uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
    884883    }
    885884
    … …  
    10531052    uvmx = (tx + ((tx&3) == 3)) >> 1;
    10541053    uvmy = (ty + ((ty&3) == 3)) >> 1;
     1054    if(v->fastuvmc) {
     1055        uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
     1056        uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
     1057    }
    10551058
    10561059    uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
    … …  
    11011104            }
    11021105        }
    1103     }
    1104 
    1105     if(v->fastuvmc) {
    1106         uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
    1107         uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
    11081106    }
    11091107
    … …  
    15921590    case 1:
    15931591        v->s.pict_type = B_TYPE;
    1594         return -1;
    1595 //      break;
     1592        break;
    15961593    case 2:
    15971594        v->s.pict_type = I_TYPE;
    … …  
    16221619        v->uvsamp = get_bits1(gb);
    16231620    if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
     1621    if(v->s.pict_type == B_TYPE) {
     1622        v->bfraction = get_vlc2(gb, vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
     1623        v->bfraction = vc1_bfraction_lut[v->bfraction];
     1624        if(v->bfraction == 0) {
     1625            v->s.pict_type = BI_TYPE; /* XXX: should not happen here */
     1626        }
     1627    }
    16241628    pqindex = get_bits(gb, 5);
    16251629    v->pqindex = pqindex;
    … …  
    17361740
    17371741        v->ttfrm = 0; //FIXME Is that so ?
     1742        if (v->vstransform)
     1743        {
     1744            v->ttmbf = get_bits(gb, 1);
     1745            if (v->ttmbf)
     1746            {
     1747                v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
     1748            }
     1749        } else {
     1750            v->ttmbf = 1;
     1751            v->ttfrm = TT_8X8;
     1752        }
     1753        break;
     1754    case B_TYPE:
     1755        if(v->postprocflag)
     1756            v->postproc = get_bits1(gb);
     1757        if (v->extended_mv) v->mvrange = get_prefix(gb, 0, 3);
     1758        else v->mvrange = 0;
     1759        v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
     1760        v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
     1761        v->range_x = 1 << (v->k_x - 1);
     1762        v->range_y = 1 << (v->k_y - 1);
     1763
     1764        if (v->pq < 5) v->tt_index = 0;
     1765        else if(v->pq < 13) v->tt_index = 1;
     1766        else v->tt_index = 2;
     1767
     1768        lowquant = (v->pq > 12) ? 0 : 1;
     1769        v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
     1770        v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
     1771        v->s.mspel = v->s.quarter_sample;
     1772
     1773        status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
     1774        if (status < 0) return -1;
     1775        av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
     1776               "Imode: %i, Invert: %i\n", status>>1, status&1);
     1777        status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
     1778        if (status < 0) return -1;
     1779        av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
     1780               "Imode: %i, Invert: %i\n", status>>1, status&1);
     1781
     1782        v->s.mv_table_index = get_bits(gb, 2);
     1783        v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
     1784
     1785        if (v->dquant)
     1786        {
     1787            av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
     1788            vop_dquant_decoding(v);
     1789        }
     1790
     1791        v->ttfrm = 0;
    17381792        if (v->vstransform)
    17391793        {
    … …  
    20062060    uvmx = (mx + ((mx & 3) == 3)) >> 1;
    20072061    uvmy = (my + ((my & 3) == 3)) >> 1;
     2062    if(v->fastuvmc) {
     2063        uvmx = uvmx + ((uvmx<0)?-(uvmx&1):(uvmx&1));
     2064        uvmy = uvmy + ((uvmy<0)?-(uvmy&1):(uvmy&1));
     2065    }
    20082066    srcY = s->next_picture.data[0];
    20092067    srcU = s->next_picture.data[1];
    … …  
    20662124        }
    20672125        srcY += s->mspel * (1 + s->linesize);
    2068     }
    2069 
    2070     if(v->fastuvmc) {
    2071         uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
    2072         uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
    20732126    }
    20742127
    … …  
    28442897            /* scale predictors if needed*/
    28452898            if(q2 && q1!=q2) {
    2846                 q1 = q1 * 2 - 1;
    2847                 q2 = q2 * 2 - 1;
     2899                q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
     2900                q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
    28482901
    28492902                if(dc_pred_dir) { //left
    … …  
    28872940                memcpy(ac_val2, ac_val, 8 * 2);
    28882941                if(q2 && q1!=q2) {
    2889                     q1 = q1 * 2 - 1;
    2890                     q2 = q2 * 2 - 1;
     2942                    q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
     2943                    q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
    28912944                    for(k = 1; k < 8; k++)
    28922945                        ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
    … …  
    28972950                memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
    28982951                if(q2 && q1!=q2) {
    2899                     q1 = q1 * 2 - 1;
    2900                     q2 = q2 * 2 - 1;
     2952                    q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
     2953                    q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
    29012954                    for(k = 1; k < 8; k++)
    29022955                        ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
    … …  
    30433096            /* scale predictors if needed*/
    30443097            if(q2 && q1!=q2) {
    3045                 q1 = q1 * 2 - 1;
    3046                 q2 = q2 * 2 - 1;
     3098                q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
     3099                q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
    30473100
    30483101                if(dc_pred_dir) { //left
    … …  
    30863139                memcpy(ac_val2, ac_val, 8 * 2);
    30873140                if(q2 && q1!=q2) {
    3088                     q1 = q1 * 2 - 1;
    3089                     q2 = q2 * 2 - 1;
     3141                    q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
     3142                    q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
    30903143                    for(k = 1; k < 8; k++)
    30913144                        ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
    … …  
    30963149                memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
    30973150                if(q2 && q1!=q2) {
    3098                     q1 = q1 * 2 - 1;
    3099                     q2 = q2 * 2 - 1;
     3151                    q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
     3152                    q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
    31003153                    for(k = 1; k < 8; k++)
    31013154                        ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
    … …  
    33423395                    if(v->pq >= 9 && v->overlap) {
    33433396                        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));
     3397                            s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
    33453398                        if(v->a_avail)
    3346                             s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? ((i&1)>>1) : (s->mb_y&1));
     3399                            s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
    33473400                    }
    33483401                } else if(val) {
    … …  
    34453498                    if(v->pq >= 9 && v->overlap) {
    34463499                        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));
     3500                            s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
    34483501                        if(v->a_avail)
    3449                             s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? ((i&1)>>1) : (s->mb_y&1));
     3502                            s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
    34503503                    }
    34513504                } else if(is_coded[i]) {
    … …  
    37143767            if(v->pq >= 9 && v->overlap) {
    37153768                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);
     3769                    s->dsp.vc1_h_overlap(s->dest[0], s->linesize);
     3770                    s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
    37183771                    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);
     3772                        s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
     3773                        s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
    37213774                    }
    37223775                }
    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);
     3776                s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
     3777                s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
    37253778                if(!s->first_slice_line) {
    3726                     s->dsp.vc1_v_overlap(s->dest[0], s->linesize, 0);
    3727                     s->dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize, 0);
     3779                    s->dsp.vc1_v_overlap(s->dest[0], s->linesize);
     3780                    s->dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
    37283781                    if(!(s->flags & CODEC_FLAG_GRAY)) {
    3729                         s->dsp.vc1_v_overlap(s->dest[1], s->uvlinesize, s->mb_y&1);
    3730                         s->dsp.vc1_v_overlap(s->dest[2], s->uvlinesize, s->mb_y&1);
     3782                        s->dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
     3783                        s->dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
    37313784                    }
    37323785                }
    3733                 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize, 1);
    3734                 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize, 1);
     3786                s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
     3787                s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
    37353788            }
    37363789
    … …  
    37833836        break;
    37843837    }
    3785 
    3786     /* Set DC scale - y and c use the same */
    3787     s->y_dc_scale = s->y_dc_scale_table[v->pq];
    3788     s->c_dc_scale = s->c_dc_scale_table[v->pq];
    37893838
    37903839    //do frame decode
    … …  
    38213870
    38223871            s->current_picture.qscale_table[mb_pos] = mquant;
     3872            /* Set DC scale - y and c use the same */
     3873            s->y_dc_scale = s->y_dc_scale_table[mquant];
     3874            s->c_dc_scale = s->c_dc_scale_table[mquant];
    38233875
    38243876            for(k = 0; k < 6; k++) {
    … …  
    38443896            if(overlap) {
    38453897                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);
     3898                    s->dsp.vc1_h_overlap(s->dest[0], s->linesize);
     3899                    s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
    38483900                    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);
     3901                        s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
     3902                        s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
    38513903                    }
    38523904                }
    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);
     3905                s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
     3906                s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
    38553907                if(!s->first_slice_line) {
    3856                     s->dsp.vc1_v_overlap(s->dest[0], s->linesize, 0);
    3857                     s->dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize, 0);
     3908                    s->dsp.vc1_v_overlap(s->dest[0], s->linesize);
     3909                    s->dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
    38583910                    if(!(s->flags & CODEC_FLAG_GRAY)) {
    3859                         s->dsp.vc1_v_overlap(s->dest[1], s->uvlinesize, s->mb_y&1);
    3860                         s->dsp.vc1_v_overlap(s->dest[2], s->uvlinesize, s->mb_y&1);
     3911                        s->dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
     3912                        s->dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
    38613913                    }
    38623914                }
    3863                 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize, 1);
    3864                 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize, 1);
     3915                s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
     3916                s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
    38653917            }
    38663918

  • TabularUnified trunk/libavcodec/vc1dsp.c

    r263 r269  
    3232/** Apply overlap transform to horizontal edge
    3333*/
    34 static void vc1_v_overlap_c(uint8_t* src, int stride, int rnd)
     34static void vc1_v_overlap_c(uint8_t* src, int stride)
    3535{
    3636    int i;
    3737    int a, b, c, d;
    3838    int d1, d2;
     39    int rnd = 1;
    3940    for(i = 0; i < 8; i++) {
    4041        a = src[-2*stride];
    … …  
    5051        src[stride] = d + d1;
    5152        src++;
     53        rnd = !rnd;
    5254    }
    5355}
    … …  
    5557/** Apply overlap transform to vertical edge
    5658*/
    57 static void vc1_h_overlap_c(uint8_t* src, int stride, int rnd)
     59static void vc1_h_overlap_c(uint8_t* src, int stride)
    5860{
    5961    int i;
    6062    int a, b, c, d;
    6163    int d1, d2;
     64    int rnd = 1;
    6265    for(i = 0; i < 8; i++) {
    6366        a = src[-2];
    … …  
    7376        src[1] = d + d1;
    7477        src += stride;
     78        rnd = !rnd;
    7579    }
    7680}

  • TabularUnified trunk/libavcodec/vqavideo.c

    r256 r269  
    2424 * @file vqavideo.c
    2525 * VQA Video Decoder by Mike Melanson (melanson@pcisys.net)
    26  * For more information about the RPZA format, visit:
    27  *   http://www.pcisys.net/~melanson/codecs/
     26 * For more information about the VQA format, visit:
     27 *   http://wiki.multimedia.cx/index.php?title=VQA
    2828 *
    2929 * The VQA video decoder outputs PAL8 or RGB555 colorspace data, depending
    … …  
    472472/* still need sample media for this case (only one game, "Legend of
    473473 * Kyrandia III : Malcolm's Revenge", is known to use this version) */
    474                 lines = 0;
     474                lobyte = s->decode_buffer[lobytes * 2];
     475                hibyte = s->decode_buffer[(lobytes * 2) + 1];
     476                vector_index = ((hibyte << 8) | lobyte) >> 3;
     477                vector_index <<= index_shift;
     478                lines = s->vector_height;
     479                /* uniform color fill - a quick hack */
     480                if (hibyte == 0xFF) {
     481                    while (lines--) {
     482                        s->frame.data[0][pixel_ptr + 0] = 255 - lobyte;
     483                        s->frame.data[0][pixel_ptr + 1] = 255 - lobyte;
     484                        s->frame.data[0][pixel_ptr + 2] = 255 - lobyte;
     485                        s->frame.data[0][pixel_ptr + 3] = 255 - lobyte;
     486                        pixel_ptr += s->frame.linesize[0];
     487                    }
     488                    lines=0;
     489                }
    475490                break;
    476491

  • TabularUnified trunk/libavcodec/wmadec.c

    r256 r269  
    712712}
    713713
     714DECLARE_ALIGNED_16(float, window[BLOCK_MAX_SIZE * 2]);
     715DECLARE_ALIGNED_16(FFTSample, output[BLOCK_MAX_SIZE * 2]);
     716
    714717/* return 0 if OK. return 1 if last block of frame. return -1 if
    715718   unrecorrable error. */
    … …  
    718721    int n, v, a, ch, code, bsize;
    719722    int coef_nb_bits, total_gain, parse_exponents;
    720     DECLARE_ALIGNED_16(float, window[BLOCK_MAX_SIZE * 2]);
     723    //DECLARE_ALIGNED_16(float, window[BLOCK_MAX_SIZE * 2]);
    721724    int nb_coefs[MAX_CHANNELS];
    722725    float mdct_norm;
    … …  
    11081111    for(ch = 0; ch < s->nb_channels; ch++) {
    11091112        if (s->channel_coded[ch]) {
    1110             DECLARE_ALIGNED_16(FFTSample, output[BLOCK_MAX_SIZE * 2]);
     1113            //DECLARE_ALIGNED_16(FFTSample, output[BLOCK_MAX_SIZE * 2]);
    11111114            float *ptr;
    11121115            int n4, index, n;

  • TabularUnified trunk/libavformat/allformats.c

    r263 r269  
    2222#include "allformats.h"
    2323
     24#define REGISTER_MUXER(X,x) \
     25          if(ENABLE_##X##_MUXER)   av_register_output_format(&x##_muxer)
     26#define REGISTER_DEMUXER(X,x) \
     27          if(ENABLE_##X##_DEMUXER) av_register_input_format(&x##_demuxer)
     28#define REGISTER_MUXDEMUX(X,x)  REGISTER_MUXER(X,x); REGISTER_DEMUXER(X,x)
     29
    2430/* If you do not call this function, then you can select exactly which
    2531   formats you want to support */
    … …  
    3945    avcodec_register_all();
    4046
    41 #ifdef CONFIG_FOURXM_DEMUXER
    42     av_register_input_format(&fourxm_demuxer);
     47    REGISTER_DEMUXER (AAC, aac);
     48    REGISTER_MUXDEMUX(AC3, ac3);
     49    REGISTER_MUXER   (ADTS, adts);
     50    REGISTER_MUXDEMUX(AIFF, aiff);
     51    REGISTER_MUXDEMUX(AMR, amr);
     52    REGISTER_MUXDEMUX(ASF, asf);
     53    REGISTER_MUXER   (ASF_STREAM, asf_stream);
     54    REGISTER_MUXDEMUX(AU, au);
     55#if defined(CONFIG_AUDIO_OSS) || defined(CONFIG_AUDIO_BEOS)
     56    REGISTER_MUXDEMUX(AUDIO, audio);
    4357#endif
    44 #ifdef CONFIG_ADTS_MUXER
    45     av_register_output_format(&adts_muxer);
    46 #endif
    47 #ifdef CONFIG_AIFF_DEMUXER
    48     av_register_input_format(&aiff_demuxer);
    49 #endif
    50 #ifdef CONFIG_AIFF_MUXER
    51     av_register_output_format(&aiff_muxer);
    52 #endif
    53 #ifdef CONFIG_AMR_DEMUXER
    54     av_register_input_format(&amr_demuxer);
    55 #endif
    56 #ifdef CONFIG_AMR_MUXER
    57     av_register_output_format(&amr_muxer);
    58 #endif
    59 #ifdef CONFIG_ASF_DEMUXER
    60     av_register_input_format(&asf_demuxer);
    61 #endif
    62 #ifdef CONFIG_ASF_MUXER
    63     av_register_output_format(&asf_muxer);
    64 #endif
    65 #ifdef CONFIG_ASF_STREAM_MUXER
    66     av_register_output_format(&asf_stream_muxer);
    67 #endif
    68 #ifdef CONFIG_AU_DEMUXER
    69     av_register_input_format(&au_demuxer);
    70 #endif
    71 #ifdef CONFIG_AU_MUXER
    72     av_register_output_format(&au_muxer);
    73 #endif
    74 #if defined(CONFIG_AUDIO_OSS) || defined(CONFIG_AUDIO_BEOS)
    75 #ifdef CONFIG_AUDIO_DEMUXER
    76     av_register_input_format(&audio_demuxer);
    77 #endif
    78 #ifdef CONFIG_AUDIO_MUXER
    79     av_register_output_format(&audio_muxer);
    80 #endif
    81 #endif /* CONFIG_AUDIO_OSS || CONFIG_AUDIO_BEOS */
    82 #ifdef CONFIG_AVI_DEMUXER
    83     av_register_input_format(&avi_demuxer);
    84 #endif
    85 #ifdef CONFIG_AVI_MUXER
    86     av_register_output_format(&avi_muxer);
    87 #endif
     58    REGISTER_MUXDEMUX(AVI, avi);
    8859#ifdef CONFIG_AVISYNTH
    8960    av_register_input_format(&avisynth_demuxer);
    9061#endif
    91 #ifdef CONFIG_AVS_DEMUXER
    92     av_register_input_format(&avs_demuxer);
     62    REGISTER_DEMUXER (AVS, avs);
     63    REGISTER_MUXER   (CRC, crc);
     64    REGISTER_DEMUXER (DAUD, daud);
     65#ifdef CONFIG_DC1394
     66    REGISTER_DEMUXER (DC1394, dc1394);
    9367#endif
    94 #ifdef CONFIG_CRC_MUXER
    95     av_register_output_format(&crc_muxer);
     68    REGISTER_DEMUXER (DSICIN, dsicin);
     69    REGISTER_DEMUXER (DTS, dts);
     70    REGISTER_MUXDEMUX(DV, dv);
     71#ifdef CONFIG_DV1394
     72    REGISTER_DEMUXER (DV1394, dv1394);
    9673#endif
    97 #ifdef CONFIG_FRAMECRC_MUXER
    98     av_register_output_format(&framecrc_muxer);
     74    REGISTER_DEMUXER (EA, ea);
     75    REGISTER_MUXDEMUX(FFM, ffm);
     76    REGISTER_MUXDEMUX(FLAC, flac);
     77    REGISTER_DEMUXER (FLIC, flic);
     78    REGISTER_MUXDEMUX(FLV, flv);
     79    REGISTER_DEMUXER (FOURXM, fourxm);
     80    REGISTER_MUXER   (FRAMECRC, framecrc);
     81    REGISTER_MUXDEMUX(GIF, gif);
     82    REGISTER_DEMUXER (GXF, gxf);
     83#ifdef CONFIG_GPL
     84    REGISTER_MUXER   (GXF, gxf);
    9985#endif
    100 #ifdef CONFIG_DAUD_DEMUXER
    101     av_register_input_format(&daud_demuxer);
     86    REGISTER_MUXDEMUX(H261, h261);
     87    REGISTER_MUXDEMUX(H263, h263);
     88    REGISTER_MUXDEMUX(H264, h264);
     89    REGISTER_DEMUXER (IDCIN, idcin);
     90    REGISTER_MUXDEMUX(IMAGE2, image2);
     91    REGISTER_MUXDEMUX(IMAGE2PIPE, image2pipe);
     92    REGISTER_DEMUXER (INGENIENT, ingenient);
     93    REGISTER_DEMUXER (IPMOVIE, ipmovie);
     94    REGISTER_MUXDEMUX(M4V, m4v);
     95    REGISTER_DEMUXER (MATROSKA, matroska);
     96    REGISTER_MUXDEMUX(MJPEG, mjpeg);
     97    REGISTER_DEMUXER (MM, mm);
     98    REGISTER_MUXDEMUX(MMF, mmf);
     99    REGISTER_MUXDEMUX(MOV, mov);
     100    REGISTER_MUXER   (MP2, mp2);
     101    REGISTER_MUXDEMUX(MP3, mp3);
     102    REGISTER_MUXER   (MP4, mp4);
     103    REGISTER_MUXER   (MPEG1SYSTEM, mpeg1system);
     104    REGISTER_MUXER   (MPEG1VCD, mpeg1vcd);
     105    REGISTER_MUXER   (MPEG1VIDEO, mpeg1video);
     106    REGISTER_MUXER   (MPEG2DVD, mpeg2dvd);
     107    REGISTER_MUXER   (MPEG2SVCD, mpeg2svcd);
     108    REGISTER_MUXER   (MPEG2VIDEO, mpeg2video);
     109    REGISTER_MUXER   (MPEG2VOB, mpeg2vob);
     110    REGISTER_DEMUXER (MPEGPS, mpegps);
     111    REGISTER_MUXDEMUX(MPEGTS, mpegts);
     112    REGISTER_DEMUXER (MPEGVIDEO, mpegvideo);
     113    REGISTER_MUXER   (MPJPEG, mpjpeg);
     114    REGISTER_DEMUXER (MTV, mtv);
     115    REGISTER_DEMUXER (MXF, mxf);
     116    REGISTER_DEMUXER (NSV, nsv);
     117    REGISTER_MUXER   (NULL, null);
     118    REGISTER_DEMUXER (NUT, nut);
     119#ifdef CONFIG_LIBNUT
     120    REGISTER_MUXER   (NUT, nut);
    102121#endif
    103 #ifdef CONFIG_DC1394
    104 #ifdef CONFIG_DC1394_DEMUXER
    105     av_register_input_format(&dc1394_demuxer);
     122    REGISTER_DEMUXER (NUV, nuv);
     123    REGISTER_DEMUXER (OGG, ogg);
     124#ifdef CONFIG_LIBOGG
     125    REGISTER_MUXER   (OGG, ogg);
    106126#endif
    107 #endif /* CONFIG_DC1394 */
    108 #ifdef CONFIG_DSICIN_DEMUXER
    109     av_register_input_format(&dsicin_demuxer);
     127    REGISTER_MUXDEMUX(PCM_ALAW,  pcm_alaw);
     128    REGISTER_MUXDEMUX(PCM_MULAW, pcm_mulaw);
     129    REGISTER_MUXDEMUX(PCM_S16BE, pcm_s16be);
     130    REGISTER_MUXDEMUX(PCM_S16LE, pcm_s16le);
     131    REGISTER_MUXDEMUX(PCM_S8,    pcm_s8);
     132    REGISTER_MUXDEMUX(PCM_U16BE, pcm_u16be);
     133    REGISTER_MUXDEMUX(PCM_U16LE, pcm_u16le);
     134    REGISTER_MUXDEMUX(PCM_U8,    pcm_u8);
     135    REGISTER_MUXER   (PSP, psp);
     136    REGISTER_MUXDEMUX(RAWVIDEO, rawvideo);
     137    REGISTER_MUXDEMUX(RM, rm);
     138    REGISTER_DEMUXER (ROQ, roq);
     139#ifdef CONFIG_NETWORK
     140    REGISTER_DEMUXER (REDIR, redir);
     141    REGISTER_MUXER   (RTP, rtp);
     142    REGISTER_DEMUXER (RTSP, rtsp);
     143    REGISTER_DEMUXER (SDP, sdp);
     144    av_register_rtp_dynamic_payload_handlers();
    110145#endif
    111 #ifdef CONFIG_DV1394
    112 #ifdef CONFIG_DV1394_DEMUXER
    113     av_register_input_format(&dv1394_demuxer);
     146    REGISTER_DEMUXER (SEGAFILM, segafilm);
     147    REGISTER_DEMUXER (SHORTEN, shorten);
     148    REGISTER_DEMUXER (SMACKER, smacker);
     149    REGISTER_DEMUXER (SOL, sol);
     150    REGISTER_DEMUXER (STR, str);
     151    REGISTER_MUXDEMUX(SWF, swf);
     152    REGISTER_MUXER   (TG2, tg2);
     153    REGISTER_MUXER   (TGP, tgp);
     154    REGISTER_DEMUXER (TIERTEXSEQ, tiertexseq);
     155    REGISTER_DEMUXER (TTA, tta);
     156#ifdef CONFIG_VIDEO4LINUX2
     157    REGISTER_DEMUXER (V4L2, v4l2);
    114158#endif
    115 #endif /* CONFIG_DV1394 */
    116 #ifdef CONFIG_DV_DEMUXER
    117     av_register_input_format(&dv_demuxer);
     159#if defined(CONFIG_VIDEO4LINUX) || defined(CONFIG_BKTR)
     160    REGISTER_DEMUXER (VIDEO_GRAB_DEVICE, video_grab_device);
    118161#endif
    119 #ifdef CONFIG_DV_MUXER
    120     av_register_output_format(&dv_muxer);
    121 #endif
    122 #ifdef CONFIG_EA_DEMUXER
    123     av_register_input_format(&ea_demuxer);
    124 #endif
    125 #ifdef CONFIG_FFM_DEMUXER
    126     av_register_input_format(&ffm_demuxer);
    127 #endif
    128 #ifdef CONFIG_FFM_MUXER
    129     av_register_output_format(&ffm_muxer);
    130 #endif
    131 #ifdef CONFIG_FLIC_DEMUXER
    132     av_register_input_format(&flic_demuxer);
    133 #endif
    134 #ifdef CONFIG_FLV_DEMUXER
    135     av_register_input_format(&flv_demuxer);
    136 #endif
    137 #ifdef CONFIG_FLV_MUXER
    138     av_register_output_format(&flv_muxer);
    139 #endif
    140 #ifdef CONFIG_GIF_MUXER
    141     av_register_output_format(&gif_muxer);
    142 #endif
    143 #ifdef CONFIG_GIF_DEMUXER
    144     av_register_input_format(&gif_demuxer);
    145 #endif
    146 #ifdef CONFIG_GXF_DEMUXER
    147     av_register_input_format(&gxf_demuxer);
    148 #endif
    149 #if defined(CONFIG_GXF_MUXER) && defined(CONFIG_GPL)
    150     av_register_output_format(&gxf_muxer);
    151 #endif
    152 #ifdef CONFIG_IDCIN_DEMUXER
    153     av_register_input_format(&idcin_demuxer);
    154 #endif
    155 #ifdef CONFIG_ROQ_DEMUXER
    156     av_register_input_format(&roq_demuxer);
    157 #endif
    158 #ifdef CONFIG_IMAGE2_DEMUXER
    159     av_register_input_format(&image2_demuxer);
    160 #endif
    161 #ifdef CONFIG_IMAGE2PIPE_DEMUXER
    162     av_register_input_format(&image2pipe_demuxer);
    163 #endif
    164 #ifdef CONFIG_IMAGE2_MUXER
    165     av_register_output_format(&image2_muxer);
    166 #endif
    167 #ifdef CONFIG_IMAGE2PIPE_MUXER
    168     av_register_output_format(&image2pipe_muxer);
    169 #endif
    170 #ifdef CONFIG_IPMOVIE_DEMUXER
    171     av_register_input_format(&ipmovie_demuxer);
    172 #endif
    173 #ifdef CONFIG_MATROSKA_DEMUXER
    174     av_register_input_format(&matroska_demuxer);
    175 #endif
    176 #ifdef CONFIG_MM_DEMUXER
    177     av_register_input_format(&mm_demuxer);
    178 #endif
    179 #ifdef CONFIG_MMF_DEMUXER
    180     av_register_input_format(&mmf_demuxer);
    181 #endif
    182 #ifdef CONFIG_MMF_MUXER
    183     av_register_output_format(&mmf_muxer);
    184 #endif
    185 #ifdef CONFIG_MOV_DEMUXER
    186     av_register_input_format(&mov_demuxer);
    187 #endif
    188 #ifdef CONFIG_MOV_MUXER
    189     av_register_output_format(&mov_muxer);
    190 #endif
    191 #ifdef CONFIG_MTV_DEMUXER
    192     av_register_input_format(&mtv_demuxer);
    193 #endif
    194 #ifdef CONFIG_TGP_MUXER
    195     av_register_output_format(&tgp_muxer);
    196 #endif
    197 #ifdef CONFIG_MP4_MUXER
    198     av_register_output_format(&mp4_muxer);
    199 #endif
    200 #ifdef CONFIG_PSP_MUXER
    201     av_register_output_format(&psp_muxer);
    202 #endif
    203 #ifdef CONFIG_TG2_MUXER
    204     av_register_output_format(&tg2_muxer);
    205 #endif
    206 #ifdef CONFIG_MP3_DEMUXER
    207     av_register_input_format(&mp3_demuxer);
    208 #endif
    209 #ifdef CONFIG_MP2_MUXER
    210     av_register_output_format(&mp2_muxer);
    211 #endif
    212 #ifdef CONFIG_MP3_MUXER
    213     av_register_output_format(&mp3_muxer);
    214 #endif
    215 #ifdef CONFIG_MPEG1SYSTEM_MUXER
    216     av_register_output_format(&mpeg1system_muxer);
    217 #endif
    218 #ifdef CONFIG_MPEG1VCD_MUXER
    219     av_register_output_format(&mpeg1vcd_muxer);
    220 #endif
    221 #ifdef CONFIG_MPEG2VOB_MUXER
    222     av_register_output_format(&mpeg2vob_muxer);
    223 #endif
    224 #ifdef CONFIG_MPEG2SVCD_MUXER
    225     av_register_output_format(&mpeg2svcd_muxer);
    226 #endif
    227 #ifdef CONFIG_MPEG2DVD_MUXER
    228     av_register_output_format(&mpeg2dvd_muxer);
    229 #endif
    230 #ifdef CONFIG_MPEGPS_DEMUXER
    231     av_register_input_format(&mpegps_demuxer);
    232 #endif
    233 #ifdef CONFIG_MPEGTS_DEMUXER
    234     av_register_input_format(&mpegts_demuxer);
    235 #endif
    236 #ifdef CONFIG_MPEGTS_MUXER
    237     av_register_output_format(&mpegts_muxer);
    238 #endif
    239 #ifdef CONFIG_MPJPEG_MUXER
    240     av_register_output_format(&mpjpeg_muxer);
    241 #endif
    242 #ifdef CONFIG_MXF_DEMUXER
    243     av_register_input_format(&mxf_demuxer);
    244 #endif
    245 #ifdef CONFIG_NSV_DEMUXER
    246     av_register_input_format(&nsv_demuxer);
    247 #endif
    248 #ifdef CONFIG_NUT_DEMUXER
    249     av_register_input_format(&nut_demuxer);
    250 #endif
    251 #ifdef CONFIG_NUT_MUXER
    252 #ifdef CONFIG_LIBNUT
    253     av_register_output_format(&nut_muxer);
    254 #endif
    255 #endif
    256 #ifdef CONFIG_NUV_DEMUXER
    257     av_register_input_format(&nuv_demuxer);
    258 #endif
    259 #ifdef CONFIG_OGG_DEMUXER
    260     av_register_input_format(&ogg_demuxer);
    261 #endif
    262 #ifdef CONFIG_LIBOGG
    263 #ifdef CONFIG_OGG_MUXER
    264     av_register_output_format(&ogg_muxer);
    265 #endif
    266 #endif /* CONFIG_LIBOGG */
    267 #ifdef CONFIG_STR_DEMUXER
    268     av_register_input_format(&str_demuxer);
    269 #endif
    270 #ifdef CONFIG_SHORTEN_DEMUXER
    271     av_register_input_format(&shorten_demuxer);
    272 #endif
    273 #ifdef CONFIG_FLAC_DEMUXER
    274     av_register_input_format(&flac_demuxer);
    275 #endif
    276 #ifdef CONFIG_FLAC_MUXER
    277     av_register_output_format(&flac_muxer);
    278 #endif
    279 #ifdef CONFIG_AC3_DEMUXER
    280     av_register_input_format(&ac3_demuxer);
    281 #endif
    282 #ifdef CONFIG_AC3_MUXER
    283     av_register_output_format(&ac3_muxer);
    284 #endif
    285 #ifdef CONFIG_DTS_DEMUXER
    286     av_register_input_format(&dts_demuxer);
    287 #endif
    288 #ifdef CONFIG_AAC_DEMUXER
    289     av_register_input_format(&aac_demuxer);
    290 #endif
    291 #ifdef CONFIG_H261_DEMUXER
    292     av_register_input_format(&h261_demuxer);
    293 #endif
    294 #ifdef CONFIG_H261_MUXER
    295     av_register_output_format(&h261_muxer);
    296 #endif
    297 #ifdef CONFIG_H263_DEMUXER
    298     av_register_input_format(&h263_demuxer);
    299 #endif
    300 #ifdef CONFIG_H263_MUXER
    301     av_register_output_format(&h263_muxer);
    302 #endif
    303 #ifdef CONFIG_M4V_DEMUXER
    304     av_register_input_format(&m4v_demuxer);
    305 #endif
    306 #ifdef CONFIG_M4V_MUXER
    307     av_register_output_format(&m4v_muxer);
    308 #endif
    309 #ifdef CONFIG_H264_DEMUXER
    310     av_register_input_format(&h264_demuxer);
    311 #endif
    312 #ifdef CONFIG_H264_MUXER
    313     av_register_output_format(&h264_muxer);
    314 #endif
    315 #ifdef CONFIG_MPEGVIDEO_DEMUXER
    316     av_register_input_format(&mpegvideo_demuxer);
    317 #endif
    318 #ifdef CONFIG_MPEG1VIDEO_MUXER
    319     av_register_output_format(&mpeg1video_muxer);
    320 #endif
    321 #ifdef CONFIG_MPEG2VIDEO_MUXER
    322     av_register_output_format(&mpeg2video_muxer);
    323 #endif
    324 #ifdef CONFIG_MJPEG_DEMUXER
    325     av_register_input_format(&mjpeg_demuxer);
    326 #endif
    327 #ifdef CONFIG_INGENIENT_DEMUXER
    328     av_register_input_format(&ingenient_demuxer);
    329 #endif
    330 #ifdef CONFIG_MJPEG_MUXER
    331     av_register_output_format(&mjpeg_muxer);
    332 #endif
    333 #ifdef CONFIG_PCM_S16LE_DEMUXER
    334     av_register_input_format(&pcm_s16le_demuxer);
    335 #endif
    336 #ifdef CONFIG_PCM_S16LE_MUXER
    337     av_register_output_format(&pcm_s16le_muxer);
    338 #endif
    339 #ifdef CONFIG_PCM_S16BE_DEMUXER
    340     av_register_input_format(&pcm_s16be_demuxer);
    341 #endif
    342 #ifdef CONFIG_PCM_S16BE_MUXER
    343     av_register_output_format(&pcm_s16be_muxer);
    344 #endif
    345 #ifdef CONFIG_PCM_U16LE_DEMUXER
    346     av_register_input_format(&pcm_u16le_demuxer);
    347 #endif
    348 #ifdef CONFIG_PCM_U16LE_MUXER
    349     av_register_output_format(&pcm_u16le_muxer);
    350 #endif
    351 #ifdef CONFIG_PCM_U16BE_DEMUXER
    352     av_register_input_format(&pcm_u16be_demuxer);
    353 #endif
    354 #ifdef CONFIG_PCM_U16BE_MUXER
    355     av_register_output_format(&pcm_u16be_muxer);
    356 #endif
    357 #ifdef CONFIG_PCM_S8_DEMUXER
    358     av_register_input_format(&pcm_s8_demuxer);
    359 #endif
    360 #ifdef CONFIG_PCM_S8_MUXER
    361     av_register_output_format(&pcm_s8_muxer);
    362 #endif
    363 #ifdef CONFIG_PCM_U8_DEMUXER
    364     av_register_input_format(&pcm_u8_demuxer);
    365 #endif
    366 #ifdef CONFIG_PCM_U8_MUXER
    367     av_register_output_format(&pcm_u8_muxer);
    368 #endif
    369 #ifdef CONFIG_PCM_MULAW_DEMUXER
    370     av_register_input_format(&pcm_mulaw_demuxer);
    371 #endif
    372 #ifdef CONFIG_PCM_MULAW_MUXER
    373     av_register_output_format(&pcm_mulaw_muxer);
    374 #endif
    375 #ifdef CONFIG_PCM_ALAW_DEMUXER
    376     av_register_input_format(&pcm_alaw_demuxer);
    377 #endif
    378 #ifdef CONFIG_PCM_ALAW_MUXER
    379     av_register_output_format(&pcm_alaw_muxer);
    380 #endif
    381 #ifdef CONFIG_RAWVIDEO_DEMUXER
    382     av_register_input_format(&rawvideo_demuxer);
    383 #endif
    384 #ifdef CONFIG_RAWVIDEO_MUXER
    385     av_register_output_format(&rawvideo_muxer);
    386 #endif
    387 #ifdef CONFIG_NULL_MUXER
    388     av_register_output_format(&null_muxer);
    389 #endif
    390 #ifdef CONFIG_RM_DEMUXER
    391     av_register_input_format(&rm_demuxer);
    392 #endif
    393 #ifdef CONFIG_RM_MUXER
    394     av_register_output_format(&rm_muxer);
    395 #endif
    396 #ifdef CONFIG_NETWORK
    397 #ifdef CONFIG_RTP_MUXER
    398     av_register_output_format(&rtp_muxer);
    399 #endif
    400 #ifdef CONFIG_RTSP_DEMUXER
    401     av_register_input_format(&rtsp_demuxer);
    402 #endif
    403 #ifdef CONFIG_SDP_DEMUXER
    404     av_register_input_format(&sdp_demuxer);
    405 #endif
    406 #ifdef CONFIG_REDIR_DEMUXER
    407     av_register_input_format(&redir_demuxer);
    408 #endif
    409     av_register_rtp_dynamic_payload_handlers();
    410 #endif /* CONFIG_NETWORK */
    411 #ifdef CONFIG_SEGAFILM_DEMUXER
    412     av_register_input_format(&segafilm_demuxer);
    413 #endif
    414 #ifdef CONFIG_VMD_DEMUXER
    415     av_register_input_format(&vmd_demuxer);
    416 #endif
    417 #ifdef CONFIG_SMACKER_DEMUXER
    418     av_register_input_format(&smacker_demuxer);
    419 #endif
    420 #ifdef CONFIG_SOL_DEMUXER
    421     av_register_input_format(&sol_demuxer);
    422 #endif
    423 #ifdef CONFIG_SWF_DEMUXER
    424     av_register_input_format(&swf_demuxer);
    425 #endif
    426 #ifdef CONFIG_SWF_MUXER
    427     av_register_output_format(&swf_muxer);
    428 #endif
    429 #ifdef CONFIG_TTA_DEMUXER
    430     av_register_input_format(&tta_demuxer);
    431 #endif
    432 #ifdef CONFIG_VIDEO4LINUX2
    433 #ifdef CONFIG_V4L2_DEMUXER
    434     av_register_input_format(&v4l2_demuxer);
    435 #endif
    436 #endif /* CONFIG_VIDEO4LINUX2 */
    437 #if defined(CONFIG_VIDEO4LINUX) || defined(CONFIG_BKTR)
    438 #ifdef CONFIG_VIDEO_GRAB_DEVICE_DEMUXER
    439     av_register_input_format(&video_grab_device_demuxer);
    440 #endif
    441 #endif /* CONFIG_VIDEO4LINUX || CONFIG_BKTR */
    442 #ifdef CONFIG_VOC_DEMUXER
    443     av_register_input_format(&voc_demuxer);
    444 #endif
    445 #ifdef CONFIG_VOC_MUXER
    446     av_register_output_format(&voc_muxer);
    447 #endif
    448 #ifdef CONFIG_WAV_DEMUXER
    449     av_register_input_format(&wav_demuxer);
    450 #endif
    451 #ifdef CONFIG_WAV_MUXER
    452     av_register_output_format(&wav_muxer);
    453 #endif
    454 #ifdef CONFIG_WC3_DEMUXER
    455     av_register_input_format(&wc3_demuxer);
    456 #endif
    457 #ifdef CONFIG_WSAUD_DEMUXER
    458     av_register_input_format(&wsaud_demuxer);
    459 #endif
    460 #ifdef CONFIG_WSVQA_DEMUXER
    461     av_register_input_format(&wsvqa_demuxer);
    462 #endif
    463 #ifdef CONFIG_WV_DEMUXER
    464     av_register_input_format(&wv_demuxer);
    465 #endif
    466 #ifdef CONFIG_YUV4MPEGPIPE_MUXER
    467     av_register_output_format(&yuv4mpegpipe_muxer);
    468 #endif
    469 #ifdef CONFIG_YUV4MPEGPIPE_DEMUXER
    470     av_register_input_format(&yuv4mpegpipe_demuxer);
    471 #endif
    472 #ifdef CONFIG_TIERTEXSEQ_DEMUXER
    473     av_register_input_format(&tiertexseq_demuxer);
    474 #endif
     162    REGISTER_DEMUXER (VMD, vmd);
     163    REGISTER_MUXDEMUX(VOC, voc);
     164    REGISTER_MUXDEMUX(WAV, wav);
     165    REGISTER_DEMUXER (WC3, wc3);
     166    REGISTER_DEMUXER (WSAUD, wsaud);
     167    REGISTER_DEMUXER (WSVQA, wsvqa);
     168    REGISTER_DEMUXER (WV, wv);
     169    REGISTER_MUXDEMUX(YUV4MPEGPIPE, yuv4mpegpipe);
    475170
    476171#ifdef CONFIG_PROTOCOLS

  • TabularUnified trunk/libavformat/aviobuf.c

    r259 r269  
    137137        s->buf_ptr = s->buf_end + offset - s->pos;
    138138    } else {
    139 #ifdef CONFIG_MUXERS
     139#if defined(CONFIG_MUXERS) || defined(CONFIG_NETWORK)
    140140        if (s->write_flag) {
    141141            flush_buffer(s);
    142142            s->must_flush = 1;
    143143        } else
    144 #endif //CONFIG_MUXERS
     144#endif /* defined(CONFIG_MUXERS) || defined(CONFIG_NETWORK) */
    145145        {
    146146            s->buf_end = s->buffer;
    … …  
    623623}
    624624
    625 #ifdef CONFIG_MUXERS
     625/* url_open_dyn_buf and url_close_dyn_buf are used in rtp.c to send a response
     626 * back to the server even if CONFIG_MUXERS is not set. */
     627#if defined(CONFIG_MUXERS) || defined(CONFIG_NETWORK)
    626628/* buffer handling */
    627629int url_open_buf(ByteIOContext *s, uint8_t *buf, int buf_size, int flags)
    … …  
    786788    return size;
    787789}
    788 #endif //CONFIG_MUXERS
     790#endif /* CONFIG_MUXERS || CONFIG_NETWORK */

  • TabularUnified trunk/libavformat/flvenc.c

    r261 r269  
    6666        break;
    6767    case CODEC_ID_PCM_S16BE:
    68         flags |= 0x60 | 0x2;
     68        flags |= 0x2;
    6969        break;
    7070    case CODEC_ID_PCM_S16LE:
    71         flags |= 0x2;
     71        flags |= 0x30 | 0x2;
    7272        break;
    7373    case CODEC_ID_ADPCM_SWF:

  • TabularUnified trunk/libavformat/gxf.c

    r257 r269  
    131131            st->codec->codec_type = CODEC_TYPE_VIDEO;
    132132            st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
     133            st->need_parsing = 2; // get keyframe flag etc.
    133134            break;
    134135        case 22:
    … …  
    136137            st->codec->codec_type = CODEC_TYPE_VIDEO;
    137138            st->codec->codec_id = CODEC_ID_MPEG1VIDEO;
     139            st->need_parsing = 2; // get keyframe flag etc.
    138140            break;
    139141        case 9:
    … …  
    160162            st->codec->channels = 2;
    161163            st->codec->sample_rate = 48000;
     164            break;
     165        // timecode tracks:
     166        case 7:
     167        case 8:
     168        case 24:
     169            st->codec->codec_type = CODEC_TYPE_DATA;
     170            st->codec->codec_id = CODEC_ID_NONE;
    162171            break;
    163172        default:

  • TabularUnified trunk/libavformat/gxfenc.c

    r259 r269  
    4646    int first_gop_closed;
    4747    int64_t current_dts;
     48    int dts_delay;
    4849} GXFStreamContext;
    4950
    … …  
    786787
    787788    for (i = 0; i < s->nb_streams; i++) {
    788         if (s->streams[i]->codec->codec_type == CODEC_TYPE_AUDIO) {
    789             GXFStreamContext *sc = &gxf->streams[i];
     789        AVStream *st = s->streams[i];
     790        GXFStreamContext *sc = &gxf->streams[i];
     791        if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
    790792            if (pkt && pkt->stream_index == i) {
    791793                av_fifo_write(&sc->audio_buffer, pkt->data, pkt->size);
    … …  
    798800                }
    799801            }
     802        } else if (pkt) {
     803            /* adjust dts if negative */
     804            if (pkt->dts < 0 && !sc->dts_delay) {
     805                /* XXX: rescale if codec time base is different from stream time base */
     806                sc->dts_delay = av_rescale_q(pkt->dts, st->codec->time_base, st->time_base);
     807                pkt->dts = sc->dts_delay; /* set to 0 */
     808            }
     809            pkt->dts -= sc->dts_delay;
    800810        }
    801811    }

  • TabularUnified trunk/libavformat/matroska.c

    r263 r269  
    225225    {"A_VORBIS"         , CODEC_ID_VORBIS},
    226226    {"A_AAC"            , CODEC_ID_AAC},
     227    {"A_FLAC"           , CODEC_ID_FLAC},
    227228    {"A_WAVPACK4"       , CODEC_ID_WAVPACK},
     229    {"A_TTA1"           , CODEC_ID_TTA},
    228230    {NULL               , CODEC_ID_NONE}
    229231/* TODO: AC3-9/10 (?), Real, Musepack, Quicktime */
    … …  
    22632265                    extradata_size = 2;
    22642266                }
     2267            }
     2268
     2269            else if (codec_id == CODEC_ID_TTA) {
     2270                MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *) track;
     2271                ByteIOContext b;
     2272                extradata_size = 30;
     2273                extradata = av_mallocz(extradata_size);
     2274                if (extradata == NULL)
     2275                    return AVERROR_NOMEM;
     2276                init_put_byte(&b, extradata, extradata_size, 1,
     2277                              NULL, NULL, NULL, NULL);
     2278                put_buffer(&b, (uint8_t *) "TTA1", 4);
     2279                put_le16(&b, 1);
     2280                put_le16(&b, audiotrack->channels);
     2281                put_le16(&b, audiotrack->bitdepth);
     2282                put_le32(&b, audiotrack->samplerate);
     2283                put_le32(&b, matroska->ctx->duration * audiotrack->samplerate);
    22652284            }
    22662285
    … …  
    25182537                        if (cluster_time != (uint64_t)-1 && n == 0) {
    25192538                            if (cluster_time + block_time >= 0)
    2520                                 timecode = cluster_time + block_time;
     2539                                timecode = (cluster_time + block_time) * matroska->time_scale;
    25212540                        }
    25222541                        /* FIXME: duration */

  • TabularUnified trunk/libavformat/mxf.c

    r263 r269  
    759759{
    760760    MXFPackage *material_package = NULL;
    761     MXFPackage *source_package = NULL;
    762761    MXFPackage *temp_package = NULL;
    763762    int i, j, k;
    … …  
    781780
    782781    for (i = 0; i < material_package->tracks_count; i++) {
     782        MXFPackage *source_package = NULL;
    783783        MXFTrack *material_track = NULL;
    784784        MXFTrack *source_track = NULL;

  • TabularUnified trunk/libavformat/segafilm.c

    r256 r269  
    5959    unsigned int base_clock;
    6060    unsigned int version;
    61     int cvid_extra_bytes;  /* the number of bytes thrown into the Cinepak
    62                             * chunk header to throw off decoders */
    6361
    6462    /* buffer used for interleaving stereo PCM data */
    … …  
    127125        return AVERROR_INVALIDDATA;
    128126
    129     film->cvid_extra_bytes = 0;
    130127    if (BE_32(&scratch[8]) == CVID_TAG) {
    131128        film->video_type = CODEC_ID_CINEPAK;
    132         if (film->version)
    133             film->cvid_extra_bytes = 2;
    134         else
    135             film->cvid_extra_bytes = 6;  /* Lemmings 3DO case */
    136129    } else
    137130        film->video_type = 0;
    … …  
    232225    if ((sample->stream == film->video_stream_index) &&
    233226        (film->video_type == CODEC_ID_CINEPAK)) {
    234         if (av_new_packet(pkt, sample->sample_size - film->cvid_extra_bytes))
    235             return AVERROR_NOMEM;
    236         if(pkt->size < 10)
    237             return -1;
    238227        pkt->pos= url_ftell(pb);
    239         ret = get_buffer(pb, pkt->data, 10);
    240         /* skip the non-spec CVID bytes */
    241         url_fseek(pb, film->cvid_extra_bytes, SEEK_CUR);
    242         ret += get_buffer(pb, pkt->data + 10,
    243             sample->sample_size - 10 - film->cvid_extra_bytes);
    244         if (ret != sample->sample_size - film->cvid_extra_bytes)
    245             ret = AVERROR_IO;
     228        if (av_new_packet(pkt, sample->sample_size))
     229            return AVERROR_NOMEM;
     230        get_buffer(pb, pkt->data, sample->sample_size);
    246231    } else if ((sample->stream == film->audio_stream_index) &&
    247232        (film->audio_channels == 2)) {

  • TabularUnified trunk/libavformat/voc.c

    r256 r269  
    11/*
    2  * Creative Voice File demuxer.
     2 * Creative Voice File common data.
    33 * Copyright (c) 2006  Aurelien Jacobs <aurel@gnuage.org>
    44 *
    … …  
    2020 */
    2121
    22 #include "avformat.h"
    23 #include "riff.h"    /* for CodecTag */
    2422#include "voc.h"
    2523
     24const unsigned char voc_magic[21] = "Creative Voice File\x1A";
    2625
    27 typedef enum voc_type {
    28     VOC_TYPE_EOF              = 0x00,
    29     VOC_TYPE_VOICE_DATA       = 0x01,
    30     VOC_TYPE_VOICE_DATA_CONT  = 0x02,
    31     VOC_TYPE_SILENCE          = 0x03,
    32     VOC_TYPE_MARKER           = 0x04,
    33     VOC_TYPE_ASCII            = 0x05,
    34     VOC_TYPE_REPETITION_START = 0x06,
    35     VOC_TYPE_REPETITION_END   = 0x07,
    36     VOC_TYPE_EXTENDED         = 0x08,
    37     VOC_TYPE_NEW_VOICE_DATA   = 0x09,
    38 } voc_type_t;
    39 
    40 
    41 static const int voc_max_pkt_size = 2048;
    42 static const unsigned char voc_magic[] = "Creative Voice File\x1A";
    43 
    44 static const CodecTag voc_codec_tags[] = {
     26const CodecTag voc_codec_tags[] = {
    4527    {CODEC_ID_PCM_U8,        0x00},
    4628    {CODEC_ID_ADPCM_SBPRO_4, 0x01},
    … …  
    5335    {0, 0},
    5436};
    55 
    56 
    57 #ifdef CONFIG_DEMUXERS
    58 
    59 static int voc_probe(AVProbeData *p)
    60 {
    61     int version, check;
    62 
    63     if (p->buf_size < 26)
    64         return 0;
    65     if (memcmp(p->buf, voc_magic, sizeof(voc_magic) - 1))
    66         return 0;
    67     version = p->buf[22] | (p->buf[23] << 8);
    68     check = p->buf[24] | (p->buf[25] << 8);
    69     if (~version + 0x1234 != check)
    70         return 10;
    71 
    72     return AVPROBE_SCORE_MAX;
    73 }
    74 
    75 static int voc_read_header(AVFormatContext *s, AVFormatParameters *ap)
    76 {
    77     voc_dec_context_t *voc = s->priv_data;
    78     ByteIOContext *pb = &s->pb;
    79     int header_size;
    80     AVStream *st;
    81 
    82     url_fskip(pb, 20);
    83     header_size = get_le16(pb) - 22;
    84     if (header_size != 4) {
    85         av_log(s, AV_LOG_ERROR, "unkown header size: %d\n", header_size);
    86         return AVERROR_NOTSUPP;
    87     }
    88     url_fskip(pb, header_size);
    89     st = av_new_stream(s, 0);
    90     if (!st)
    91         return AVERROR_NOMEM;
    92     st->codec->codec_type = CODEC_TYPE_AUDIO;
    93 
    94     voc->remaining_size = 0;
    95     return 0;
    96 }
    97 
    98 int
    99 voc_get_packet(AVFormatContext *s, AVPacket *pkt, AVStream *st, int max_size)
    100 {
    101     voc_dec_context_t *voc = s->priv_data;
    102     AVCodecContext *dec = st->codec;
    103     ByteIOContext *pb = &s->pb;
    104     voc_type_t type;
    105     int size;
    106     int sample_rate = 0;
    107     int channels = 1;
    108 
    109     while (!voc->remaining_size) {
    110         type = get_byte(pb);
    111         if (type == VOC_TYPE_EOF)
    112             return AVERROR_IO;
    113         voc->remaining_size = get_le24(pb);
    114         max_size -= 4;
    115 
    116         switch (type) {
    117         case VOC_TYPE_VOICE_DATA:
    118             dec->sample_rate = 1000000 / (256 - get_byte(pb));
    119             if (sample_rate)
    120                 dec->sample_rate = sample_rate;
    121             dec->channels = channels;
    122             dec->codec_id = codec_get_id(voc_codec_tags, get_byte(pb));
    123             dec->bits_per_sample = av_get_bits_per_sample(dec->codec_id);
    124             voc->remaining_size -= 2;
    125             max_size -= 2;
    126             channels = 1;
    127             break;
    128 
    129         case VOC_TYPE_VOICE_DATA_CONT:
    130             break;
    131 
    132         case VOC_TYPE_EXTENDED:
    133             sample_rate = get_le16(pb);
    134             get_byte(pb);
    135             channels = get_byte(pb) + 1;
    136             sample_rate = 256000000 / (channels * (65536 - sample_rate));
    137             voc->remaining_size = 0;
    138             max_size -= 4;
    139             break;
    140 
    141         case VOC_TYPE_NEW_VOICE_DATA:
    142             dec->sample_rate = get_le32(pb);
    143             dec->bits_per_sample = get_byte(pb);
    144             dec->channels = get_byte(pb);
    145             dec->codec_id = codec_get_id(voc_codec_tags, get_le16(pb));
    146             url_fskip(pb, 4);
    147             voc->remaining_size -= 12;
    148             max_size -= 12;
    149             break;
    150 
    151         default:
    152             url_fskip(pb, voc->remaining_size);
    153             max_size -= voc->remaining_size;
    154             voc->remaining_size = 0;
    155             break;
    156         }
    157     }
    158 
    159     dec->bit_rate = dec->sample_rate * dec->bits_per_sample;
    160 
    161     if (max_size <= 0)
    162         max_size = voc_max_pkt_size;
    163     size = FFMIN(voc->remaining_size, max_size);
    164     voc->remaining_size -= size;
    165     return av_get_packet(pb, pkt, size);
    166 }
    167 
    168 static int voc_read_packet(AVFormatContext *s, AVPacket *pkt)
    169 {
    170     return voc_get_packet(s, pkt, s->streams[0], 0);
    171 }
    172 
    173 static int voc_read_close(AVFormatContext *s)
    174 {
    175     return 0;
    176 }
    177 
    178 AVInputFormat voc_demuxer = {
    179     "voc",
    180     "Creative Voice File format",
    181     sizeof(voc_dec_context_t),
    182     voc_probe,
    183     voc_read_header,
    184     voc_read_packet,
    185     voc_read_close,
    186 };
    187 
    188 #endif /* CONFIG_DEMUXERS */
    189 
    190 
    191 #ifdef CONFIG_MUXERS
    192 
    193 typedef struct voc_enc_context {
    194     int param_written;
    195 } voc_enc_context_t;
    196 
    197 static int voc_write_header(AVFormatContext *s)
    198 {
    199     ByteIOContext *pb = &s->pb;
    200     const int header_size = 26;
    201     const int version = 0x0114;
    202 
    203     if (s->nb_streams != 1
    204         || s->streams[0]->codec->codec_type != CODEC_TYPE_AUDIO)
    205         return AVERROR_NOTSUPP;
    206 
    207     put_buffer(pb, voc_magic, sizeof(voc_magic) - 1);
    208     put_le16(pb, header_size);
    209     put_le16(pb, version);
    210     put_le16(pb, ~version + 0x1234);
    211 
    212     return 0;
    213 }
    214 
    215 static int voc_write_packet(AVFormatContext *s, AVPacket *pkt)
    216 {
    217     voc_enc_context_t *voc = s->priv_data;
    218     AVCodecContext *enc = s->streams[0]->codec;
    219     ByteIOContext *pb = &s->pb;
    220 
    221     if (!voc->param_written) {
    222         int format = codec_get_tag(voc_codec_tags, enc->codec_id);
    223 
    224         if (format > 0xFF) {
    225             put_byte(pb, VOC_TYPE_NEW_VOICE_DATA);
    226             put_le24(pb, pkt->size + 12);
    227             put_le32(pb, enc->sample_rate);
    228             put_byte(pb, enc->bits_per_sample);
    229             put_byte(pb, enc->channels);
    230             put_le16(pb, format);
    231             put_le32(pb, 0);
    232         } else {
    233             if (s->streams[0]->codec->channels > 1) {
    234                 put_byte(pb, VOC_TYPE_EXTENDED);
    235                 put_le24(pb, 4);
    236                 put_le16(pb, 65536-256000000/(enc->sample_rate*enc->channels));
    237                 put_byte(pb, format);
    238                 put_byte(pb, enc->channels - 1);
    239             }
    240             put_byte(pb, VOC_TYPE_VOICE_DATA);
    241             put_le24(pb, pkt->size + 2);
    242             put_byte(pb, 256 - 1000000 / enc->sample_rate);
    243             put_byte(pb, format);
    244         }
    245         voc->param_written = 1;
    246     } else {
    247         put_byte(pb, VOC_TYPE_VOICE_DATA_CONT);
    248         put_le24(pb, pkt->size);
    249     }
    250 
    251     put_buffer(pb, pkt->data, pkt->size);
    252     return 0;
    253 }
    254 
    255 static int voc_write_trailer(AVFormatContext *s)
    256 {
    257     put_byte(&s->pb, 0);
    258     return 0;
    259 }
    260 
    261 AVOutputFormat voc_muxer = {
    262     "voc",
    263     "Creative Voice File format",
    264     "audio/x-voc",
    265     "voc",
    266     sizeof(voc_enc_context_t),
    267     CODEC_ID_PCM_U8,
    268     CODEC_ID_NONE,
    269     voc_write_header,
    270     voc_write_packet,
    271     voc_write_trailer,
    272 };
    273 
    274 #endif /* CONFIG_MUXERS */

  • TabularUnified trunk/libavformat/voc.h

    r256 r269  
    2424
    2525#include "avformat.h"
     26#include "riff.h"    /* for CodecTag */
    2627
    2728typedef struct voc_dec_context {
    … …  
    2930} voc_dec_context_t;
    3031
     32typedef enum voc_type {
     33    VOC_TYPE_EOF              = 0x00,
     34    VOC_TYPE_VOICE_DATA       = 0x01,
     35    VOC_TYPE_VOICE_DATA_CONT  = 0x02,
     36    VOC_TYPE_SILENCE          = 0x03,
     37    VOC_TYPE_MARKER           = 0x04,
     38    VOC_TYPE_ASCII            = 0x05,
     39    VOC_TYPE_REPETITION_START = 0x06,
     40    VOC_TYPE_REPETITION_END   = 0x07,
     41    VOC_TYPE_EXTENDED         = 0x08,
     42    VOC_TYPE_NEW_VOICE_DATA   = 0x09,
     43} voc_type_t;
     44
     45extern const unsigned char voc_magic[21];
     46extern const CodecTag voc_codec_tags[];
     47
    3148int voc_get_packet(AVFormatContext *s, AVPacket *pkt,
    3249                   AVStream *st, int max_size);

  • TabularUnified trunk/libavformat/westwood.c

    r256 r269  
    4545#define FINF_TAG MKBETAG('F', 'I', 'N', 'F')
    4646#define SND0_TAG MKBETAG('S', 'N', 'D', '0')
     47#define SND1_TAG MKBETAG('S', 'N', 'D', '1')
    4748#define SND2_TAG MKBETAG('S', 'N', 'D', '2')
    4849#define VQFR_TAG MKBETAG('V', 'Q', 'F', 'R')
    … …  
    5556#define PINH_TAG MKBETAG('P', 'I', 'N', 'H')
    5657#define PIND_TAG MKBETAG('P', 'I', 'N', 'D')
     58#define CMDS_TAG MKBETAG('C', 'M', 'D', 'S')
    5759
    5860#define VQA_HEADER_SIZE 0x2A
    … …  
    223225    if (!st)
    224226        return AVERROR_NOMEM;
    225     av_set_pts_info(st, 33, 1, 90000);
     227    av_set_pts_info(st, 33, 1, VQA_FRAMERATE);
    226228    wsvqa->video_stream_index = st->index;
    227229    st->codec->codec_type = CODEC_TYPE_VIDEO;
    … …  
    244246    st->codec->height = LE_16(&header[8]);
    245247
    246     /* initialize the audio decoder stream is sample rate is non-zero */
    247     if (LE_16(&header[24])) {
     248    /* initialize the audio decoder stream for VQA v1 or nonzero samplerate */
     249    if (LE_16(&header[24]) || (LE_16(&header[0]) == 1 && LE_16(&header[2]) == 1)) {
    248250        st = av_new_stream(s, 0);
    249251        if (!st)
    250252            return AVERROR_NOMEM;
    251         av_set_pts_info(st, 33, 1, 90000);
     253        av_set_pts_info(st, 33, 1, VQA_FRAMERATE);
    252254        st->codec->codec_type = CODEC_TYPE_AUDIO;
    253         st->codec->codec_id = CODEC_ID_ADPCM_IMA_WS;
     255        if (LE_16(&header[0]) == 1)
     256            st->codec->codec_id = CODEC_ID_WESTWOOD_SND1;
     257        else
     258            st->codec->codec_id = CODEC_ID_ADPCM_IMA_WS;
    254259        st->codec->codec_tag = 0;  /* no tag */
    255260        st->codec->sample_rate = LE_16(&header[24]);
     261        if (!st->codec->sample_rate)
     262            st->codec->sample_rate = 22050;
    256263        st->codec->channels = header[26];
     264        if (!st->codec->channels)
     265            st->codec->channels = 1;
    257266        st->codec->bits_per_sample = 16;
    258267        st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *
    … …  
    285294        case PIND_TAG:
    286295        case FINF_TAG:
     296        case CMDS_TAG:
    287297            break;
    288298
    … …  
    307317    WsVqaDemuxContext *wsvqa = (WsVqaDemuxContext *)s->priv_data;
    308318    ByteIOContext *pb = &s->pb;
    309     int ret = 0;
     319    int ret = -1;
    310320    unsigned char preamble[VQA_PREAMBLE_SIZE];
    311321    unsigned int chunk_type;
    … …  
    313323    int skip_byte;
    314324
    315     if (get_buffer(pb, preamble, VQA_PREAMBLE_SIZE) != VQA_PREAMBLE_SIZE)
    316         return AVERROR_IO;
    317 
    318     chunk_type = BE_32(&preamble[0]);
    319     chunk_size = BE_32(&preamble[4]);
    320     skip_byte = chunk_size & 0x01;
    321 
    322     if ((chunk_type == SND2_TAG) || (chunk_type == VQFR_TAG)) {
    323 
    324         av_get_packet(pb, pkt, chunk_size);
    325         if (ret != chunk_size) {
    326             ret = AVERROR_IO;
     325    while (get_buffer(pb, preamble, VQA_PREAMBLE_SIZE) == VQA_PREAMBLE_SIZE) {
     326        chunk_type = BE_32(&preamble[0]);
     327        chunk_size = BE_32(&preamble[4]);
     328        skip_byte = chunk_size & 0x01;
     329
     330        if ((chunk_type == SND1_TAG) || (chunk_type == SND2_TAG) || (chunk_type == VQFR_TAG)) {
     331
     332            if (av_new_packet(pkt, chunk_size))
     333                return AVERROR_IO;
     334            ret = get_buffer(pb, pkt->data, chunk_size);
     335            if (ret != chunk_size) {
     336                av_free_packet(pkt);
     337                return AVERROR_IO;
     338            }
     339
     340            if (chunk_type == SND2_TAG) {
     341                pkt->stream_index = wsvqa->audio_stream_index;
     342                /* 2 samples/byte, 1 or 2 samples per frame depending on stereo */
     343                wsvqa->audio_frame_counter += (chunk_size * 2) / wsvqa->audio_channels;
     344            } else if(chunk_type == SND1_TAG) {
     345                pkt->stream_index = wsvqa->audio_stream_index;
     346                /* unpacked size is stored in header */
     347                wsvqa->audio_frame_counter += LE_16(pkt->data) / wsvqa->audio_channels;
     348            } else {
     349                pkt->stream_index = wsvqa->video_stream_index;
     350                wsvqa->video_pts += VQA_VIDEO_PTS_INC;
     351            }
     352            /* stay on 16-bit alignment */
     353            if (skip_byte)
     354                url_fseek(pb, 1, SEEK_CUR);
     355
     356            return ret;
     357        } else {
     358            switch(chunk_type){
     359            case CMDS_TAG:
     360            case SND0_TAG:
     361                break;
     362            default:
     363                av_log(s, AV_LOG_INFO, "Skipping unknown chunk 0x%08X\n", chunk_type);
     364            }
     365            url_fseek(pb, chunk_size + skip_byte, SEEK_CUR);
    327366        }
    328 
    329         if (chunk_type == SND2_TAG) {
    330             pkt->stream_index = wsvqa->audio_stream_index;
    331 
    332             pkt->pts = 90000;
    333             pkt->pts *= wsvqa->audio_frame_counter;
    334             pkt->pts /= wsvqa->audio_samplerate;
    335 
    336             /* 2 samples/byte, 1 or 2 samples per frame depending on stereo */
    337             wsvqa->audio_frame_counter += (chunk_size * 2) /
    338                 wsvqa->audio_channels;
    339         } else {
    340             pkt->stream_index = wsvqa->video_stream_index;
    341             pkt->pts = wsvqa->video_pts;
    342             wsvqa->video_pts += VQA_VIDEO_PTS_INC;
    343         }
    344 
    345     } else
    346         return AVERROR_INVALIDDATA;
    347 
    348     /* stay on 16-bit alignment */
    349     if (skip_byte)
    350         url_fseek(pb, 1, SEEK_CUR);
     367    }
    351368
    352369    return ret;

  • TabularUnified trunk/libavutil/common.h

    r263 r269  
    265265 * @param amin minimum value of the clip range
    266266 * @param amax maximum value of the clip range
    267  * @return cliped value
     267 * @return clipped value
    268268 */
    269269static inline int clip(int a, int amin, int amax)
    … …  
    277277 * clip a signed integer value into the 0-255 range
    278278 * @param a value to clip
    279  * @return cliped value
     279 * @return clipped value
    280280 */
    281281static inline uint8_t clip_uint8(int a)

  • TabularUnified trunk/libavutil/config.h

    r263 r269  
    1515//#define __MMX__
    1616//#define HAVE_BUILTIN_VECTOR ///????
     17#define CONFIG_MUXERS
     18#define CONFIG_DEMUXERS
     19
     20#define CONFIG_MPEGAUDIO_PARSER
     21#define CONFIG_AVI_DEMUXER
     22#define CONFIG_AVI_MUXER
     23#define ENABLE_DV_DEMUXER 0
     24#define CONFIG_FLV_DEMUXER
     25#define CONFIG_FLV_MUXER
     26#define CONFIG_MATROSKA_DEMUXER
     27#define CONFIG_MMF_DEMUXER
     28#define CONFIG_MPEGPS_DEMUXER
     29#define CONFIG_MPEGTS_DEMUXER
     30#define CONFIG_MPEGVIDEO_DEMUXER
     31#define CONFIG_MPEG1VIDEO_MUXER
     32#define CONFIG_SWF_DEMUXER
     33#define CONFIG_ZLIB
     34#define FFMPEG_CONFIGURATION
     35//#define EMULATE_FAST_INT
     36
    1737#define HAVE_LRINTF
    1838#define HAVE_THREADS
    … …  
    2747#define CONFIG_MPEGAUDIO_HP 1
    2848
    29 #define CONFIG_MP2_ENCODER
    30 #define CONFIG_MPEG1VIDEO_ENCODER
    31 #define CONFIG_H264_ENCODER
    32 #define CONFIG_MPEG2VIDEO_ENCODER
    33 #define CONFIG_H261_ENCODER
    34 #define CONFIG_H263_ENCODER
    35 #define CONFIG_H263P_ENCODER
    36 #define CONFIG_FLV_ENCODER
    37 #define CONFIG_RV10_ENCODER
    38 #define CONFIG_RV20_ENCODER
    39 #define CONFIG_MPEG4_ENCODER
    40 #define CONFIG_MSMPEG4V1_ENCODER
    41 #define CONFIG_MSMPEG4V2_ENCODER
    42 #define CONFIG_MSMPEG4V3_ENCODER
    43 #define CONFIG_WMV1_ENCODER
    44 #define CONFIG_WMV2_ENCODER
    45 #define CONFIG_SVQ1_ENCODER
    46 #define CONFIG_MJPEG_ENCODER
    47 #define CONFIG_LJPEG_ENCODER
    48 #define CONFIG_HUFFYUV_ENCODER
    49 #define CONFIG_FFVHUFF_ENCODER
    50 #define CONFIG_ASV1_ENCODER
    51 #define CONFIG_ASV2_ENCODER
    52 #define CONFIG_FFV1_ENCODER
    53 #define CONFIG_SNOW_ENCODER
    54 #define CONFIG_DVVIDEO_ENCODER
    55 #define CONFIG_SONIC_ENCODER
    56 #define CONFIG_SONIC_LS_ENCODER
    57 #define CONFIG_RAWVIDEO_ENCODER
    58 #define CONFIG_RAWVIDEO_DECODER
    59 #define CONFIG_H263_DECODER
    60 #define CONFIG_H261_DECODER
    61 #define CONFIG_MPEG4_DECODER
    62 #define CONFIG_MSMPEG4V1_DECODER
    63 #define CONFIG_MSMPEG4V2_DECODER
    64 #define CONFIG_MSMPEG4V3_DECODER
    65 #define CONFIG_WMV1_DECODER
    66 #define CONFIG_WMV2_DECODER
    67 #define CONFIG_VC1_DECODER
    68 #define CONFIG_WMV3_DECODER
    69 #define CONFIG_H263I_DECODER
    70 #define CONFIG_FLV_DECODER
    71 #define CONFIG_RV10_DECODER
    72 #define CONFIG_RV20_DECODER
    73 #define CONFIG_SVQ1_DECODER
    74 #define CONFIG_SVQ3_DECODER
    75 #define CONFIG_WMAV1_DECODER
    76 #define CONFIG_WMAV2_DECODER
    77 #define CONFIG_INDEO2_DECODER
    78 #define CONFIG_INDEO3_DECODER
    79 #define CONFIG_TSCC_DECODER
    80 #define CONFIG_ULTI_DECODER
    81 #define CONFIG_QDRAW_DECODER
    82 #define CONFIG_XL_DECODER
    83 #define CONFIG_QPEG_DECODER
    84 #define CONFIG_LOCO_DECODER
    85 #define CONFIG_WNV1_DECODER
    86 #define CONFIG_AASC_DECODER
    87 #define CONFIG_MPEG1VIDEO_DECODER
    88 #define CONFIG_MPEG2VIDEO_DECODER
    89 #define CONFIG_MPEGVIDEO_DECODER
    90 #define CONFIG_DVVIDEO_DECODER
    91 #define CONFIG_MJPEG_DECODER
    92 #define CONFIG_MJPEGB_DECODER
    93 #define CONFIG_SP5X_DECODER
    94 #define CONFIG_MP2_DECODER
    95 #define CONFIG_MP3_DECODER
    96 #define CONFIG_MP3ADU_DECODER
    97 #define CONFIG_MP3ON4_DECODER
    98 #define CONFIG_MACE3_DECODER
    99 #define CONFIG_MACE6_DECODER
    100 #define CONFIG_HUFFYUV_DECODER
    101 #define CONFIG_FFVHUFF_DECODER
    102 #define CONFIG_FFV1_DECODER
    103 #define CONFIG_SNOW_DECODER
    104 #define CONFIG_CYUV_DECODER
    105 #define CONFIG_H264_DECODER
    106 #define CONFIG_VP3_DECODER
    107 #define CONFIG_VP5_DECODER
    108 #define CONFIG_VP6_DECODER
    109 #define CONFIG_THEORA_DECODER
    110 #define CONFIG_ASV1_DECODER
    111 #define CONFIG_ASV2_DECODER
    112 #define CONFIG_VCR1_DECODER
    113 #define CONFIG_CLJR_DECODER
    114 #define CONFIG_FOURXM_DECODER
    115 #define CONFIG_MDEC_DECODER
    116 #define CONFIG_ROQ_DECODER
    117 #define CONFIG_INTERPLAY_VIDEO_DECODER
    118 #define CONFIG_XAN_WC3_DECODER
    119 #define CONFIG_RPZA_DECODER
    120 #define CONFIG_CINEPAK_DECODER
    121 #define CONFIG_MSRLE_DECODER
    122 #define CONFIG_MSVIDEO1_DECODER
    123 #define CONFIG_VQA_DECODER
    124 #define CONFIG_IDCIN_DECODER
    125 #define CONFIG_EIGHTBPS_DECODER
    126 #define CONFIG_SMC_DECODER
    127 #define CONFIG_FLIC_DECODER
    128 #define CONFIG_TRUEMOTION1_DECODER
    129 #define CONFIG_TRUEMOTION2_DECODER
    130 #define CONFIG_VMDVIDEO_DECODER
    131 #define CONFIG_VMDAUDIO_DECODER
    132 #define CONFIG_MSZH_DECODER
    133 #define CONFIG_ZLIB_DECODER
    134 #define CONFIG_SONIC_DECODER
    135 #define CONFIG_DTS_DECODER
    136 #define CONFIG_RA_144_DECODER
    137 #define CONFIG_RA_288_DECODER
    138 #define CONFIG_ROQ_DPCM_DECODER
    139 #define CONFIG_INTERPLAY_DPCM_DECODER
    140 #define CONFIG_XAN_DPCM_DECODER
    141 #define CONFIG_SOL_DPCM_DECODER
    142 #define CONFIG_QTRLE_DECODER
    143 #define CONFIG_FLAC_DECODER
    144 #define CONFIG_SHORTEN_DECODER
    145 #define CONFIG_ALAC_DECODER
    146 #define CONFIG_WS_SND1_DECODER
    14749#define AMR_WB
    14850#define AMR_NB
    14951#define AMR_NB_FIXED
    15052#define CONFIG_AMR_NB_FIXED
    151 #define CONFIG_AMR_NB_DECODER
    152 #define CONFIG_AMR_NB_ENCODER
    153 #define CONFIG_AMR_WB_DECODER
    154 #define CONFIG_AMR_WB_ENCODER
    155 #define CONFIG_AAC_DECODER
    156 #define CONFIG_MPEG4AAC_DECODER
    157 #define CONFIG_QDM2_DECODER
    158 #define CONFIG_COOK_DECODER
    159 #define CONFIG_VORBIS_DECODER
    160 #define CONFIG_MPEGVIDEO_PARSER
    161 #define CONFIG_MPEG4VIDEO_PARSER
    162 #define CONFIG_CAVSVIDEO_PARSER
     53#define CONFIG_DVVIDEO_ENCODER
     54#define CONFIG_DVVIDEO_DECODER
    16355#define CONFIG_MPEGAUDIO_PARSER
    16456#define CONFIG_AC3_PARSER
    16557#define CONFIG_AAC_PARSER
     58#define CONFIG_MPEG4VIDEO_PARSER
     59#define CONFIG_PNG_ENCODER
     60#define CONFIG_PNG_DECODER
     61#define CONFIG_MPEGVIDEO_PARSER
     62#define CONFIG_PAM_ENCODER
     63#define CONFIG_PBM_ENCODER
     64#define CONFIG_PGMYUV_ENCODER
     65#define CONFIG_PPM_ENCODER
     66#define CONFIG_PNM_PARSER
     67#define CONFIG_PGM_ENCODER
     68#define CONFIG_JPEGLS_ENCODER
     69#define CONFIG_MP3ON4_DECODER
     70#define CONFIG_MP2_DECODER
     71#define CONFIG_MP2_ENCODER
     72#define CONFIG_MP3_DECODER
     73#define CONFIG_MP3ADU_DECODER
     74#define CONFIG_MSZH_DECODER
     75#define CONFIG_ZLIB_DECODER
     76#define CONFIG_CAVSVIDEO_PARSER
     77#define CONFIG_CAVS_DECODER
     78#define CONFIG_H264_PARSER
     79#define CONFIG_H261_PARSER
     80#define CONFIG_RAWVIDEO_ENCODER
     81#define CONFIG_H263_PARSER
     82#define CONFIG_AMR_DEMUXER
     83#define CONFIG_AIFF_DEMUXER
     84#define CONFIG_MPEG1SYSTEM_MUXER
     85#define CONFIG_MPEG1VCD_MUXER
     86#define CONFIG_MPEG2VOB_MUXER
     87#define CONFIG_MPEG2SVCD_MUXER
     88#define CONFIG_MPEG2DVD_MUXER
     89#define CONFIG_MPEGPS_DEMUXER
    16690
    16791#define ASMALIGN(ZEROBITS) ".align " #ZEROBITS "\n\t"
    16892
     93#define ENABLE_AAC_DEMUXER 0
     94#define ENABLE_AC3_MUXER 0
     95#define ENABLE_AC3_DEMUXER 0
     96#define ENABLE_ADTS_MUXER 0
     97#define ENABLE_AIFF_MUXER 0
     98#define ENABLE_AIFF_DEMUXER 1
     99#define ENABLE_AMR_MUXER 0
     100#define ENABLE_AMR_DEMUXER 1
     101#define ENABLE_ASF_MUXER 0
     102#define ENABLE_ASF_DEMUXER 0
     103#define ENABLE_ASF_STREAM_MUXER 0
     104#define ENABLE_AU_MUXER 0
     105#define ENABLE_AU_DEMUXER 0
     106#define ENABLE_AVI_MUXER 1
     107#define ENABLE_AVI_DEMUXER 1
     108#define ENABLE_AVS_DEMUXER 0
     109#define ENABLE_CRC_MUXER 0
     110#define ENABLE_DAUD_DEMUXER 0
     111#define ENABLE_DSICIN_DEMUXER 0
     112#define ENABLE_DTS_DEMUXER 1
     113#define ENABLE_DV_MUXER 0
     114#define ENABLE_EA_DEMUXER 0
     115#define ENABLE_FFM_MUXER 0
     116#define ENABLE_FFM_DEMUXER 0
     117#define ENABLE_FLAC_MUXER 0
     118#define ENABLE_FLAC_DEMUXER 0
     119#define ENABLE_FLIC_DEMUXER 0
     120#define ENABLE_FLV_MUXER 1
     121#define ENABLE_FLV_DEMUXER 1
     122#define ENABLE_FOURXM_DEMUXER 0
     123#define ENABLE_FRAMECRC_MUXER 0
     124#define ENABLE_GIF_MUXER 0
     125#define ENABLE_GIF_DEMUXER 0
     126#define ENABLE_GXF_DEMUXER 0
     127#define ENABLE_GXF_MUXER 0
     128#define ENABLE_H261_MUXER 0
     129#define ENABLE_H261_DEMUXER 0
     130#define ENABLE_H263_MUXER 0
     131#define ENABLE_H263_DEMUXER 0
     132#define ENABLE_H264_MUXER 0
     133#define ENABLE_H264_DEMUXER 0
     134#define ENABLE_IDCIN_DEMUXER 0
     135#define ENABLE_IMAGE2_MUXER 0
     136#define ENABLE_IMAGE2_DEMUXER 0
     137#define ENABLE_IMAGE2PIPE_MUXER 0
     138#define ENABLE_IMAGE2PIPE_DEMUXER 0
     139#define ENABLE_INGENIENT_DEMUXER 0
     140#define ENABLE_IPMOVIE_DEMUXER 0
     141#define ENABLE_M4V_MUXER 0
     142#define ENABLE_M4V_DEMUXER 0
     143#define ENABLE_MATROSKA_DEMUXER 0
     144#define ENABLE_MJPEG_MUXER 0
     145#define ENABLE_MJPEG_DEMUXER 0
     146#define ENABLE_MM_DEMUXER 0
     147#define ENABLE_MMF_MUXER 0
     148#define ENABLE_MMF_DEMUXER 1
     149#define ENABLE_MOV_MUXER 0
     150#define ENABLE_MOV_DEMUXER 0
     151#define ENABLE_MP2_MUXER 0
     152#define ENABLE_MP3_MUXER 0
     153#define ENABLE_MP3_DEMUXER 0
     154#define ENABLE_MP4_MUXER 0
     155#define ENABLE_MPEG1SYSTEM_MUXER 1
     156#define ENABLE_MPEG1VCD_MUXER 1
     157#define ENABLE_MPEG1VIDEO_MUXER 1
     158#define ENABLE_MPEG2DVD_MUXER 1
     159#define ENABLE_MPEG2SVCD_MUXER 1
     160#define ENABLE_MPEG2VIDEO_MUXER 1
     161#define ENABLE_MPEG2VOB_MUXER 1
     162#define ENABLE_MPEGPS_DEMUXER 0
     163#define ENABLE_MPEGTS_MUXER 1
     164#define ENABLE_MPEGTS_DEMUXER 1
     165#define ENABLE_MPEGVIDEO_DEMUXER 1
     166#define ENABLE_MPJPEG_MUXER 0
     167#define ENABLE_MTV_DEMUXER 0
     168#define ENABLE_MXF_DEMUXER 0
     169#define ENABLE_NSV_DEMUXER 0
     170#define ENABLE_NULL_MUXER 0
     171#define ENABLE_NUT_DEMUXER 0
     172#define ENABLE_NUV_DEMUXER 0
     173#define ENABLE_OGG_DEMUXER 0
     174#define ENABLE_PCM_ALAW_MUXER 0
     175#define ENABLE_PCM_ALAW_DEMUXER 0
     176#define ENABLE_PCM_MULAW_MUXER 0
     177#define ENABLE_PCM_MULAW_DEMUXER 0
     178#define ENABLE_PCM_S16BE_MUXER 0
     179#define ENABLE_PCM_S16BE_DEMUXER 0
     180#define ENABLE_PCM_S16LE_MUXER 0
     181#define ENABLE_PCM_S16LE_DEMUXER 0
     182#define ENABLE_PCM_S8_MUXER 0
     183#define ENABLE_PCM_S8_DEMUXER 0
     184#define ENABLE_PCM_U16BE_MUXER 0
     185#define ENABLE_PCM_U16BE_DEMUXER 0
     186#define ENABLE_PCM_U16LE_MUXER 0
     187#define ENABLE_PCM_U16LE_DEMUXER 0
     188#define ENABLE_PCM_U8_MUXER 0
     189#define ENABLE_PCM_U8_DEMUXER 0
     190#define ENABLE_PSP_MUXER 0
     191#define ENABLE_RAWVIDEO_MUXER 0
     192#define ENABLE_RAWVIDEO_DEMUXER 0
     193#define ENABLE_RM_MUXER 0
     194#define ENABLE_RM_DEMUXER 0
     195#define ENABLE_ROQ_DEMUXER 0
     196#define ENABLE_SEGAFILM_DEMUXER 0
     197#define ENABLE_SHORTEN_DEMUXER 0
     198#define ENABLE_SMACKER_DEMUXER 0
     199#define ENABLE_SOL_DEMUXER 0
     200#define ENABLE_STR_DEMUXER 0
     201#define ENABLE_SWF_MUXER 0
     202#define ENABLE_SWF_DEMUXER 1
     203#define ENABLE_TG2_MUXER 0
     204#define ENABLE_TGP_MUXER 0
     205#define ENABLE_TIERTEXSEQ_DEMUXER 0
     206#define ENABLE_TTA_DEMUXER 0
     207#define ENABLE_VMD_DEMUXER 0
     208#define ENABLE_VOC_MUXER 0
     209#define ENABLE_VOC_DEMUXER 0
     210#define ENABLE_WAV_MUXER 0
     211#define ENABLE_WAV_DEMUXER 0
     212#define ENABLE_WC3_DEMUXER 0
     213#define ENABLE_WSAUD_DEMUXER 0
     214#define ENABLE_WSVQA_DEMUXER 0
     215#define ENABLE_WV_DEMUXER 0
     216#define ENABLE_YUV4MPEGPIPE_MUXER 0
     217#define ENABLE_YUV4MPEGPIPE_DEMUXER 0
     218
     219#define ENABLE_AASC_DECODER 1
     220#define ENABLE_ASV1_ENCODER 1
     221#define ENABLE_ASV1_DECODER 1
     222#define ENABLE_ASV2_ENCODER 1
     223#define ENABLE_ASV2_DECODER 1
     224#define ENABLE_AVS_DECODER 1
     225#define ENABLE_BMP_DECODER 1
     226#define ENABLE_CAVS_DECODER 1
     227#define ENABLE_CINEPAK_DECODER 1
     228#define ENABLE_CLJR_DECODER 1
     229#define ENABLE_CSCD_DECODER 1
     230#define ENABLE_CYUV_DECODER 1
     231#define ENABLE_DSICINVIDEO_DECODER 1
     232#define ENABLE_DVVIDEO_ENCODER 1
     233#define ENABLE_DVVIDEO_DECODER 1
     234#define ENABLE_EIGHTBPS_DECODER 1
     235#define ENABLE_FFV1_ENCODER 1
     236#define ENABLE_FFV1_DECODER 1
     237#define ENABLE_FFVHUFF_ENCODER 1
     238#define ENABLE_FFVHUFF_DECODER 1
     239#define ENABLE_FLASHSV_DECODER 1
     240#define ENABLE_FLIC_DECODER 1
     241#define ENABLE_FLV_ENCODER 1
     242#define ENABLE_FLV_DECODER 1
     243#define ENABLE_FOURXM_DECODER 1
     244#define ENABLE_FRAPS_DECODER 1
     245#define ENABLE_GIF_ENCODER 1
     246#define ENABLE_GIF_DECODER 1
     247#define ENABLE_H261_ENCODER 1
     248#define ENABLE_H261_DECODER 1
     249#define ENABLE_H263_ENCODER 1
     250#define ENABLE_H263_DECODER 1
     251#define ENABLE_H263I_DECODER 1
     252#define ENABLE_H263P_ENCODER 1
     253#define ENABLE_H264_DECODER 1
     254#define ENABLE_HUFFYUV_ENCODER 1
     255#define ENABLE_HUFFYUV_DECODER 1
     256#define ENABLE_IDCIN_DECODER 1
     257#define ENABLE_INDEO2_DECODER 1
     258#define ENABLE_INDEO3_DECODER 1
     259#define ENABLE_INTERPLAY_VIDEO_DECODER 1
     260#define ENABLE_JPEGLS_ENCODER 1
     261#define ENABLE_KMVC_DECODER 1
     262#define ENABLE_LJPEG_ENCODER 1
     263#define ENABLE_LOCO_DECODER 1
     264#define ENABLE_MDEC_DECODER 1
     265#define ENABLE_MJPEG_ENCODER 1
     266#define ENABLE_MJPEG_DECODER 1
     267#define ENABLE_MJPEGB_DECODER 1
     268#define ENABLE_MMVIDEO_DECODER 1
     269#define ENABLE_MPEG1VIDEO_ENCODER 1
     270#define ENABLE_MPEG1VIDEO_DECODER 1
     271#define ENABLE_MPEG2VIDEO_ENCODER 1
     272#define ENABLE_MPEG2VIDEO_DECODER 1
     273#define ENABLE_MPEG4_ENCODER 1
     274#define ENABLE_MPEG4_DECODER 1
     275#define ENABLE_MPEGVIDEO_DECODER 1
     276#define ENABLE_MSMPEG4V1_ENCODER 1
     277#define ENABLE_MSMPEG4V1_DECODER 1
     278#define ENABLE_MSMPEG4V2_ENCODER 1
     279#define ENABLE_MSMPEG4V2_DECODER 1
     280#define ENABLE_MSMPEG4V3_ENCODER 1
     281#define ENABLE_MSMPEG4V3_DECODER 1
     282#define ENABLE_MSRLE_DECODER 1
     283#define ENABLE_MSVIDEO1_DECODER 1
     284#define ENABLE_MSZH_DECODER 1
     285#define ENABLE_NUV_DECODER 1
     286#define ENABLE_PAM_ENCODER 1
     287#define ENABLE_PBM_ENCODER 1
     288#define ENABLE_PGM_ENCODER 1
     289#define ENABLE_PGMYUV_ENCODER 1
     290#define ENABLE_PNG_ENCODER 1
     291#define ENABLE_PNG_DECODER 1
     292#define ENABLE_PPM_ENCODER 1
     293#define ENABLE_QDRAW_DECODER 1
     294#define ENABLE_QPEG_DECODER 1
     295#define ENABLE_QTRLE_DECODER 1
     296#define ENABLE_RAWVIDEO_ENCODER 1
     297#define ENABLE_RAWVIDEO_DECODER 1
     298#define ENABLE_ROQ_DECODER 1
     299#define ENABLE_RPZA_DECODER 1
     300#define ENABLE_RV10_ENCODER 1
     301#define ENABLE_RV10_DECODER 1
     302#define ENABLE_RV20_ENCODER 1
     303#define ENABLE_RV20_DECODER 1
     304#define ENABLE_SMACKER_DECODER 1
     305#define ENABLE_SMC_DECODER 1
     306#define ENABLE_SNOW_ENCODER 1
     307#define ENABLE_SNOW_DECODER 1
     308#define ENABLE_SP5X_DECODER 1
     309#define ENABLE_SVQ1_ENCODER 1
     310#define ENABLE_SVQ1_DECODER 1
     311#define ENABLE_SVQ3_DECODER 1
     312#define ENABLE_TARGA_DECODER 1
     313#define ENABLE_THEORA_DECODER 1
     314#define ENABLE_TIERTEXSEQVIDEO_DECODER 1
     315#define ENABLE_TIFF_DECODER 1
     316#define ENABLE_TRUEMOTION1_DECODER 1
     317#define ENABLE_TRUEMOTION2_DECODER 1
     318#define ENABLE_TSCC_DECODER 1
     319#define ENABLE_ULTI_DECODER 1
     320#define ENABLE_VC1_DECODER 1
     321#define ENABLE_VCR1_DECODER 1
     322#define ENABLE_VMDVIDEO_DECODER 1
     323#define ENABLE_VMNC_DECODER 1
     324#define ENABLE_VP3_DECODER 1
     325#define ENABLE_VP5_DECODER 1
     326#define ENABLE_VP6_DECODER 1
     327#define ENABLE_VP6F_DECODER 1
     328#define ENABLE_VQA_DECODER 1
     329#define ENABLE_WMV1_ENCODER 1
     330#define ENABLE_WMV1_DECODER 1
     331#define ENABLE_WMV2_ENCODER 1
     332#define ENABLE_WMV2_DECODER 1
     333#define ENABLE_WMV3_DECODER 1
     334#define ENABLE_WNV1_DECODER 1
     335#define ENABLE_XAN_WC3_DECODER 1
     336#define ENABLE_XL_DECODER 1
     337#define ENABLE_ZLIB_ENCODER 1
     338#define ENABLE_ZLIB_DECODER 1
     339#define ENABLE_ZMBV_DECODER 1
     340#define ENABLE_AAC_DECODER 1
     341#define ENABLE_MPEG4AAC_DECODER 1
     342#define ENABLE_AC3_ENCODER 1
     343#define ENABLE_ALAC_DECODER 1
     344#define ENABLE__ENCODER 1
     345#define ENABLE__DECODER 1
     346#define ENABLE_COOK_DECODER 1
     347#define ENABLE_DSICINAUDIO_DECODER 1
     348#define ENABLE_DTS_DECODER 1
     349#define ENABLE_FLAC_ENCODER 1
     350#define ENABLE_FLAC_DECODER 1
     351#define ENABLE_IMC_DECODER 1
     352#define ENABLE_MACE3_DECODER 1
     353#define ENABLE_MACE6_DECODER 1
     354#define ENABLE_MP2_ENCODER 1
     355#define ENABLE_MP2_DECODER 1
     356#define ENABLE_MP3_DECODER 1
     357#define ENABLE_MP3ADU_DECODER 1
     358#define ENABLE_MP3ON4_DECODER 1
     359#define ENABLE_QDM2_DECODER 1
     360#define ENABLE_RA_144_DECODER 1
     361#define ENABLE_RA_288_DECODER 1
     362#define ENABLE_SHORTEN_DECODER 1
     363#define ENABLE_SMACKAUD_DECODER 1
     364#define ENABLE_SONIC_ENCODER 1
     365#define ENABLE_SONIC_DECODER 1
     366#define ENABLE_SONIC_LS_ENCODER 1
     367#define ENABLE_TRUESPEECH_DECODER 1
     368#define ENABLE_TTA_DECODER 1
     369#define ENABLE_VMDAUDIO_DECODER 1
     370#define ENABLE_VORBIS_ENCODER 1
     371#define ENABLE_VORBIS_DECODER 1
     372#define ENABLE_WAVPACK_DECODER 1
     373#define ENABLE_WMAV1_DECODER 1
     374#define ENABLE_WMAV2_DECODER 1
     375#define ENABLE_WS_SND1_DECODER 1
     376#define ENABLE_PCM_ALAW_ENCODER 1
     377#define ENABLE_PCM_ALAW_DECODER 1
     378#define ENABLE_PCM_MULAW_ENCODER 1
     379#define ENABLE_PCM_MULAW_DECODER 1
     380#define ENABLE_PCM_S8_ENCODER 1
     381#define ENABLE_PCM_S8_DECODER 1
     382#define ENABLE_PCM_S16BE_ENCODER 1
     383#define ENABLE_PCM_S16BE_DECODER 1
     384#define ENABLE_PCM_S16LE_ENCODER 1
     385#define ENABLE_PCM_S16LE_DECODER 1
     386#define ENABLE_PCM_S24BE_ENCODER 1
     387#define ENABLE_PCM_S24BE_DECODER 1
     388#define ENABLE_PCM_S24DAUD_ENCODER 1
     389#define ENABLE_PCM_S24DAUD_DECODER 1
     390#define ENABLE_PCM_S24LE_ENCODER 1
     391#define ENABLE_PCM_S24LE_DECODER 1
     392#define ENABLE_PCM_S32BE_ENCODER 1
     393#define ENABLE_PCM_S32BE_DECODER 1
     394#define ENABLE_PCM_S32LE_ENCODER 1
     395#define ENABLE_PCM_S32LE_DECODER 1
     396#define ENABLE_PCM_U8_ENCODER 1
     397#define ENABLE_PCM_U8_DECODER 1
     398#define ENABLE_PCM_U16BE_ENCODER 1
     399#define ENABLE_PCM_U16BE_DECODER 1
     400#define ENABLE_PCM_U16LE_ENCODER 1
     401#define ENABLE_PCM_U16LE_DECODER 1
     402#define ENABLE_PCM_U24BE_ENCODER 1
     403#define ENABLE_PCM_U24BE_DECODER 1
     404#define ENABLE_PCM_U24LE_ENCODER 1
     405#define ENABLE_PCM_U24LE_DECODER 1
     406#define ENABLE_PCM_U32BE_ENCODER 1
     407#define ENABLE_PCM_U32BE_DECODER 1
     408#define ENABLE_PCM_U32LE_ENCODER 1
     409#define ENABLE_PCM_U32LE_DECODER 1
     410#define ENABLE_INTERPLAY_DPCM_DECODER 1
     411#define ENABLE_ROQ_DPCM_DECODER 1
     412#define ENABLE_SOL_DPCM_DECODER 1
     413#define ENABLE_XAN_DPCM_DECODER 1
     414#define ENABLE_ADPCM_4XM_ENCODER 1
     415#define ENABLE_ADPCM_4XM_DECODER 1
     416#define ENABLE_ADPCM_ADX_ENCODER 1
     417#define ENABLE_ADPCM_ADX_DECODER 1
     418#define ENABLE_ADPCM_CT_ENCODER 1
     419#define ENABLE_ADPCM_CT_DECODER 1
     420#define ENABLE_ADPCM_EA_ENCODER 1
     421#define ENABLE_ADPCM_EA_DECODER 1
     422#define ENABLE_ADPCM_G726_ENCODER 1
     423#define ENABLE_ADPCM_G726_DECODER 1
     424#define ENABLE_ADPCM_IMA_DK3_ENCODER 1
     425#define ENABLE_ADPCM_IMA_DK3_DECODER 1
     426#define ENABLE_ADPCM_IMA_DK4_ENCODER 1
     427#define ENABLE_ADPCM_IMA_DK4_DECODER 1
     428#define ENABLE_ADPCM_IMA_QT_ENCODER 1
     429#define ENABLE_ADPCM_IMA_QT_DECODER 1
     430#define ENABLE_ADPCM_IMA_SMJPEG_ENCODER 1
     431#define ENABLE_ADPCM_IMA_SMJPEG_DECODER 1
     432#define ENABLE_ADPCM_IMA_WAV_ENCODER 1
     433#define ENABLE_ADPCM_IMA_WAV_DECODER 1
     434#define ENABLE_ADPCM_IMA_WS_ENCODER 1
     435#define ENABLE_ADPCM_IMA_WS_DECODER 1
     436#define ENABLE_ADPCM_MS_ENCODER 1
     437#define ENABLE_ADPCM_MS_DECODER 1
     438#define ENABLE_ADPCM_SBPRO_2_ENCODER 1
     439#define ENABLE_ADPCM_SBPRO_2_DECODER 1
     440#define ENABLE_ADPCM_SBPRO_3_ENCODER 1
     441#define ENABLE_ADPCM_SBPRO_3_DECODER 1
     442#define ENABLE_ADPCM_SBPRO_4_ENCODER 1
     443#define ENABLE_ADPCM_SBPRO_4_DECODER 1
     444#define ENABLE_ADPCM_SWF_ENCODER 1
     445#define ENABLE_ADPCM_SWF_DECODER 1
     446#define ENABLE_ADPCM_XA_ENCODER 1
     447#define ENABLE_ADPCM_XA_DECODER 1
     448#define ENABLE_ADPCM_YAMAHA_ENCODER 1
     449#define ENABLE_ADPCM_YAMAHA_DECODER 1
     450#define ENABLE_DVBSUB_ENCODER 1
     451#define ENABLE_DVBSUB_DECODER 1
     452#define ENABLE_DVDSUB_ENCODER 1
     453#define ENABLE_DVDSUB_DECODER 1
     454#define ENABLE_AAC_PARSER 1
     455#define ENABLE_AC3_PARSER 1
     456#define ENABLE_CAVSVIDEO_PARSER 1
     457#define ENABLE_DVBSUB_PARSER 1
     458#define ENABLE_DVDSUB_PARSER 1
     459#define ENABLE_H261_PARSER 1
     460#define ENABLE_H263_PARSER 1
     461#define ENABLE_H264_PARSER 1
     462#define ENABLE_MJPEG_PARSER 1
     463#define ENABLE_MPEG4VIDEO_PARSER 1
     464#define ENABLE_MPEGAUDIO_PARSER 1
     465#define ENABLE_MPEGVIDEO_PARSER 1
     466#define ENABLE_PNM_PARSER 1
    169467//#define EMULATE_FAST_INT
    170468#endif

  • TabularUnified trunk/libavutil/rational.c

    r257 r269  
    4747
    4848    while(den){
    49         int64_t x       = nom / den;
     49        uint64_t x      = nom / den;
    5050        int64_t next_den= nom - den*x;
    5151        int64_t a2n= x*a1.num + a0.num;
    5252        int64_t a2d= x*a1.den + a0.den;
    5353
    54         if(a2n > max || a2d > max) break;
     54        if(a2n > max || a2d > max){
     55            if(a1.num) x= (max - a0.num) / a1.num;
     56            if(a1.den) x= FFMIN(x, (max - a0.den) / a1.den);
     57
     58            if (den*(2*x*a1.den + a0.den) > nom*a1.den)
     59                a1 = (AVRational){x*a1.num + a0.num, x*a1.den + a0.den};
     60            break;
     61        }
    5562
    5663        a0= a1;

  • TabularUnified trunk/libmpdemux/asf.h

    r247 r269  
    44//#include "config.h"   /* for WORDS_BIGENDIAN */
    55#include <inttypes.h>
    6 #include "bswap.h"
     6#include "libavutil/common.h"
     7#include "libavutil/bswap.h"
    78
    89#ifndef MIN

  • TabularUnified trunk/libmpdemux/aviheader.c

    r181 r269  
    1919#include "stheader.h"
    2020
    21 //#include "bswap.h"
    2221#include "aviheader.h"
    2322
    … …  
    229228                sh_video=new_sh_video(demuxer,stream_id);
    230229                memcpy(&sh_video->video,&h,sizeof(h));
     230                sh_video->stream_delay = (float)sh_video->video.dwStart * sh_video->video.dwScale/sh_video->video.dwRate;
    231231            } else
    232232                if(h.fccType==streamtypeAUDIO){
    233233                    sh_audio=new_sh_audio(demuxer,stream_id);
    234234                    memcpy(&sh_audio->audio,&h,sizeof(h));
     235                    sh_audio->stream_delay = (float)sh_audio->audio.dwStart * sh_audio->audio.dwScale/sh_audio->audio.dwRate;
    235236                }
    236237            last_fccType=h.fccType;
    … …  
    303304                //        if(verbose>=1) print_video_header(sh_video->bih);
    304305                chunksize=0;
     306                sh_video->fps=(float)sh_video->video.dwRate/(float)sh_video->video.dwScale;
     307                sh_video->frametime=(float)sh_video->video.dwScale/(float)sh_video->video.dwRate;
    305308                // IdxFix:
    306309                idxfix_videostream=stream_id;
    … …  
    352355                        sh_audio->wf=realloc(sh_audio->wf, sizeof(WAVEFORMATEX)+sh_audio->wf->cbSize);
    353356                    }
     357                    sh_audio->format=sh_audio->wf->wFormatTag;
     358                    sh_audio->i_bps=sh_audio->wf->nAvgBytesPerSec;
    354359                    chunksize=0;
    355360                    //        if(verbose>=1) print_wave_header(sh_audio->wf);

  • TabularUnified trunk/libmpdemux/aviheader.h

    r64 r269  
    22#define _aviheader_h
    33
    4 #include "bswap.h"
     4#include "libavutil/common.h"
     5#include "libavutil/bswap.h"
     6
    57#pragma pack(1)
    68

  • TabularUnified trunk/libmpdemux/demux_avi.c

    r265 r269  
    548548        } else {
    549549            sh_audio=d_audio->sh;sh_audio->ds=d_audio;
    550             sh_audio->format=sh_audio->wf->wFormatTag;
    551         }
    552     }
    553     // calc. FPS:
    554     sh_video->fps=(float)sh_video->video.dwRate/(float)sh_video->video.dwScale;
    555     sh_video->frametime=(float)sh_video->video.dwScale/(float)sh_video->video.dwRate;
     550        }
     551    }
    556552    // calculating video bitrate:
    557553
    … …  
    601597                //             asize=sh_audio->wf->nAvgBytesPerSec*priv->numberofframes*sh_video->frametime;
    602598                asize=(float)sh_audio->wf->nAvgBytesPerSec*sh_audio->audio.dwLength*sh_audio->audio.dwScale/sh_audio->audio.dwRate;
    603                 sh_audio->i_bps=sh_audio->wf->nAvgBytesPerSec;
    604599            } else {
    605600                asize=sh_audio->audio.dwLength;
    … …  
    629624
    630625    demuxer_avi_type = demuxer->type;
    631 
    632     if (sh_video)
    633         sh_video->stream_delay = (float)sh_video->video.dwStart * sh_video->video.dwScale/sh_video->video.dwRate;
    634     if (sh_audio)
    635         sh_audio->stream_delay = (float)sh_audio->audio.dwStart * sh_audio->audio.dwScale/sh_audio->audio.dwRate;
    636626
    637627    return demuxer;
    … …  
    874864        if (sh_video->video.dwLength<=1) return DEMUXER_CTRL_GUESS;
    875865        return DEMUXER_CTRL_OK;
     866    case DEMUXER_CTRL_SWITCH_AUDIO:
     867    case DEMUXER_CTRL_SWITCH_VIDEO: {
     868        int audio = (cmd == DEMUXER_CTRL_SWITCH_AUDIO);
     869        demux_stream_t *ds = audio ? demuxer->audio : demuxer->video;
     870        void **streams = audio ? demuxer->a_streams : demuxer->v_streams;
     871        int maxid = FFMIN(100, audio ? MAX_A_STREAMS : MAX_V_STREAMS);
     872        int chunkid;
     873        if (ds->id < -1)
     874            return DEMUXER_CTRL_NOTIMPL;
     875
     876        if (*(int *)arg >= 0)
     877            ds->id = *(int *)arg;
     878        else {
     879            int i;
     880            for (i = 0; i < maxid; i++) {
     881                if (++ds->id >= maxid) ds->id = 0;
     882                if (streams[ds->id]) break;
     883            }
     884        }
     885
     886        chunkid = (ds->id / 10 + '0') | (ds->id % 10 + '0') << 8;
     887        ds->sh = NULL;
     888        if (!streams[ds->id]) // stream not available
     889            ds->id = -1;
     890        else
     891            demux_avi_select_stream(demuxer, chunkid);
     892        *(int *)arg = ds->id;
     893        return DEMUXER_CTRL_OK;
     894    }
    876895
    877896    default:

  • TabularUnified trunk/libmpdemux/demux_lavf.c

    r265 r269  
    6060    { CODEC_ID_SHORTEN,   MKTAG('s', 'h', 'r', 'n')},
    6161    { CODEC_ID_WAVPACK,   MKTAG('W', 'V', 'P', 'K')},
     62    { CODEC_ID_WESTWOOD_SND1,     MKTAG('S', 'N', 'D', '1')},
    6263    { CODEC_ID_XAN_DPCM,          MKTAG('A', 'x', 'a', 'n')},
    6364    { CODEC_ID_TTA,       MKTAG('T', 'T', 'A', '1')},

  • TabularUnified trunk/libmpdemux/demux_mov.c

    r263 r269  
    2222#include <stdlib.h>
    2323#include <unistd.h>
    24 
    25 //#include "config.h"
    26 //#include "mp_msg.h"
    27 //#include "help_mp.h"
    28 
    29 #include "stream.h"
    30 #include "demuxer.h"
    31 #include "stheader.h"
    32 
    33 #include "subreader.h"
    34 
    35 extern subtitle* vo_sub;
    36 int 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 
    42 #include "bswap.h"
    43 
    44 #include "qtpalette.h"
    45 #include "parse_mp4.h" // .MP4 specific stuff
     24#include <inttypes.h>
    4625
    4726#ifdef MACOSX
    … …  
    5231#include "components.h"
    5332#endif
     33
     34//#include "config.h"
     35//#include "mp_msg.h"
     36//#include "help_mp.h"
     37
     38#include "stream.h"
     39#include "demuxer.h"
     40#include "stheader.h"
     41
     42#include "subreader.h"
     43
     44extern subtitle* vo_sub;
     45int vo_osd_changed(int new_value);
     46#define OSDTYPE_OSD 1
     47#define OSDTYPE_SUBTITLE 2
     48#define OSDTYPE_PROGBAR 3
     49#define OSDTYPE_SPU 4
     50
     51#include "bswap.h"
     52
     53#include "qtpalette.h"
     54#include "parse_mp4.h" // .MP4 specific stuff
    5455
    5556#ifdef HAVE_ZLIB

  • TabularUnified trunk/libmpdemux/demuxer.c

    r265 r269  
    438438            if (demux->stream->type != STREAMTYPE_DVDNAV)
    439439                DosReleaseMutexSem(demux_mtx);
    440             //printf("dfb. cp01\n");fflush(stdout);
     440            printf("dfb. cp01. %i\n", ds->packs);fflush(stdout);
    441441            return 1; //ds->buffer_size;
    442442        }
    … …  
    451451        }
    452452
    453         //printf("dfb. cp1\n");fflush(stdout);
     453        printf("dfb. cp1\n");fflush(stdout);
    454454        if(!demux_fill_buffer(demux,ds)){
    455455            dprintf("ds_fill_buffer()->demux_fill_buffer() failed\n");
    456456            break; // EOF
    457457        }
    458         //printf("dfb. cp2\n");fflush(stdout);
     458        printf("dfb. cp2\n");fflush(stdout);
    459459        //printf("vc1\n");fflush(stdout);
    460460    }
    … …  
    524524        register long pos = -len;
    525525        if (unlikely(pos >= 0)) { // buffer is empty
     526            printf("dp3. cp1\n");fflush(stdout);
    526527            ds_fill_buffer(ds);
     528            printf("dp3. cp2\n");fflush(stdout);
    527529            continue;
    528530        }
    … …  
    534536        if (total_len + len > maxlen)
    535537            len = maxlen - total_len;
     538        printf("dp3. cp3\n");fflush(stdout);
    536539        len = demux_read_data(ds, mem ? &mem[total_len] : NULL, len);
     540        printf("dp3. cp4\n");fflush(stdout);
    537541        total_len += len;
    538542    } while ((head != pat || total_len < 3) && total_len < maxlen && !ds->eof);

  • TabularUnified trunk/libmpdemux/demuxer.h

    r265 r269  
    1818#define MAX_PACK_BYTES 0x2000000
    1919#else
    20 //#define MAX_PACK_BYTES 0x800000
    21 #define MAX_PACK_BYTES 0xFFFFFFFF
     20#define MAX_PACK_BYTES 0x800000
     21//#define MAX_PACK_BYTES 0xFFFFFFFF
    2222#endif
    2323#define DEMUXER_MAX_WAIT 60000L //ms

  • TabularUnified trunk/libmpdemux/ebml.c

    r268 r269  
    1111#include "stream.h"
    1212#include "ebml.h"
    13 #include "bswap.h"
    14 
     13#include "libavutil/common.h"
     14#include "libavutil/bswap.h"
     15#include "libavutil/intfloat_readwrite.h"
    1516
    1617/*
    … …  
    174175    {
    175176    case 4:
    176         {
    177             union {uint32_t i; float f;} u;
    178             u.i = stream_read_dword (s);
    179             value = u.f;
    180             break;
    181         }
     177        value = av_int2flt(stream_read_dword(s));
     178        break;
    182179
    183180    case 8:
    184         {
    185             union {uint64_t i; double d;} u;
    186             u.i = stream_read_qword (s);
    187             value = u.d;
    188             break;
    189         }
     181        value = av_int2dbl(stream_read_qword(s));
     182        break;
    190183
    191184    default:

  • TabularUnified trunk/libmpdemux/parse_es.c

    r130 r269  
    6464    int res, read;
    6565
     66  if (VIDEOBUFFER_SIZE - videobuf_len < 5)
     67    return 0;
    6668  // SYNC STREAM
    6769

  • TabularUnified trunk/libmpdemux/video.c

    r265 r269  
    4646
    4747int video_read_properties(sh_video_t *sh_video){
    48 demux_stream_t *d_video=sh_video->ds;
    49 
    50 enum {
    51         VIDEO_MPEG12,
    52         VIDEO_MPEG4,
    53         VIDEO_H264,
    54         VIDEO_OTHER
    55 } video_codec;
    56 
    57 if((d_video->demuxer->file_format == DEMUXER_TYPE_PVA) ||
    58    (d_video->demuxer->file_format == DEMUXER_TYPE_MPEG_ES) ||
    59    (d_video->demuxer->file_format == DEMUXER_TYPE_MPEG_GXF) ||
    60    (d_video->demuxer->file_format == DEMUXER_TYPE_MPEG_PES) ||
    61    (d_video->demuxer->file_format == DEMUXER_TYPE_MPEG_PS && ((! sh_video->format) || (sh_video->format==0x10000001) || (sh_video->format==0x10000002))) ||
    62    (d_video->demuxer->file_format == DEMUXER_TYPE_MPEG_TY) ||
    63    (d_video->demuxer->file_format == DEMUXER_TYPE_MPEG_TS && ((sh_video->format==0x10000001) || (sh_video->format==0x10000002)))
     48    demux_stream_t *d_video;
     49
     50    if (!sh_video) return 0;
     51
     52    d_video=sh_video->ds;
     53
     54    enum {
     55        VIDEO_MPEG12,
     56        VIDEO_MPEG4,
     57        VIDEO_H264,
     58        VIDEO_OTHER
     59    } video_codec;
     60
     61    if((d_video->demuxer->file_format == DEMUXER_TYPE_PVA) ||
     62       (d_video->demuxer->file_format == DEMUXER_TYPE_MPEG_ES) ||
     63       (d_video->demuxer->file_format == DEMUXER_TYPE_MPEG_GXF) ||
     64       (d_video->demuxer->file_format == DEMUXER_TYPE_MPEG_PES) ||
     65       (d_video->demuxer->file_format == DEMUXER_TYPE_MPEG_PS && ((! sh_video->format) || (sh_video->format==0x10000001) || (sh_video->format==0x10000002))) ||
     66       (d_video->demuxer->file_format == DEMUXER_TYPE_MPEG_TY) ||
     67       (d_video->demuxer->file_format == DEMUXER_TYPE_MPEG_TS && ((sh_video->format==0x10000001) || (sh_video->format==0x10000002)))
    6468#ifdef STREAMING_LIVE555
    65   || ((d_video->demuxer->file_format == DEMUXER_TYPE_RTP) && demux_is_mpeg_rtp_stream(d_video->demuxer))
    66 #endif
    67   )
    68     video_codec = VIDEO_MPEG12;
    69   else if((d_video->demuxer->file_format == DEMUXER_TYPE_MPEG4_ES) ||
    70     ((d_video->demuxer->file_format == DEMUXER_TYPE_MPEG_TS) && (sh_video->format==0x10000004)) ||
    71     ((d_video->demuxer->file_format == DEMUXER_TYPE_MPEG_PS) && (sh_video->format==0x10000004))
    72   )
    73     video_codec = VIDEO_MPEG4;
    74   else if((d_video->demuxer->file_format == DEMUXER_TYPE_H264_ES) ||
    75     ((d_video->demuxer->file_format == DEMUXER_TYPE_MPEG_TS) && (sh_video->format==0x10000005)) ||
    76     ((d_video->demuxer->file_format == DEMUXER_TYPE_MPEG_PS) && (sh_video->format==0x10000005))
    77   )
    78     video_codec = VIDEO_H264;
    79   else
    80     video_codec = VIDEO_OTHER;
    81    
    82 // Determine image properties:
    83 switch(video_codec){
    84  case VIDEO_OTHER: {
    85  if((d_video->demuxer->file_format == DEMUXER_TYPE_ASF) || (d_video->demuxer->file_format == DEMUXER_TYPE_AVI)) {
    86   // display info:
    87  
     69       || ((d_video->demuxer->file_format == DEMUXER_TYPE_RTP) && demux_is_mpeg_rtp_stream(d_video->demuxer))
     70#endif
     71      )
     72        video_codec = VIDEO_MPEG12;
     73    else if((d_video->demuxer->file_format == DEMUXER_TYPE_MPEG4_ES) ||
     74            ((d_video->demuxer->file_format == DEMUXER_TYPE_MPEG_TS) && (sh_video->format==0x10000004)) ||
     75            ((d_video->demuxer->file_format == DEMUXER_TYPE_MPEG_PS) && (sh_video->format==0x10000004))
     76           )
     77        video_codec = VIDEO_MPEG4;
     78    else if((d_video->demuxer->file_format == DEMUXER_TYPE_H264_ES) ||
     79            ((d_video->demuxer->file_format == DEMUXER_TYPE_MPEG_TS) && (sh_video->format==0x10000005)) ||
     80            ((d_video->demuxer->file_format == DEMUXER_TYPE_MPEG_PS) && (sh_video->format==0x10000005))
     81           )
     82        video_codec = VIDEO_H264;
     83    else
     84        video_codec = VIDEO_OTHER;
     85
     86    // Determine image properties:
     87    switch(video_codec){
     88    case VIDEO_OTHER: {
     89        if((d_video->demuxer->file_format == DEMUXER_TYPE_ASF) || (d_video->demuxer->file_format == DEMUXER_TYPE_AVI)) {
     90            // display info:
     91
    8892#if 0
    89     if(sh_video->bih->biCompression == BI_RGB &&
    90        (sh_video->video.fccHandler == mmioFOURCC('D', 'I', 'B', ' ') ||
    91         sh_video->video.fccHandler == mmioFOURCC('R', 'G', 'B', ' ') ||
    92         sh_video->video.fccHandler == mmioFOURCC('R', 'A', 'W', ' ') ||
    93         sh_video->video.fccHandler == 0)) {
     93            if(sh_video->bih->biCompression == BI_RGB &&
     94               (sh_video->video.fccHandler == mmioFOURCC('D', 'I', 'B', ' ') ||
     95                sh_video->video.fccHandler == mmioFOURCC('R', 'G', 'B', ' ') ||
     96                sh_video->video.fccHandler == mmioFOURCC('R', 'A', 'W', ' ') ||
     97                sh_video->video.fccHandler == 0)) {
    9498                sh_video->format = mmioFOURCC(0, 'R', 'G', 'B') | sh_video->bih->biBitCount;
    95     }
    96     else                                           
    97 #endif
    98         sh_video->format=sh_video->bih->biCompression;
    99 
    100     sh_video->disp_w=sh_video->bih->biWidth;
    101     sh_video->disp_h=abs(sh_video->bih->biHeight);
     99            }
     100            else
     101#endif
     102                sh_video->format=sh_video->bih->biCompression;
     103
     104            sh_video->disp_w=sh_video->bih->biWidth;
     105            sh_video->disp_h=abs(sh_video->bih->biHeight);
    102106
    103107#if 0
    104     /* hack to support decoding of mpeg1 chunks in AVI's with libmpeg2 -- 2002 alex */
    105     if ((sh_video->format == 0x10000001) ||
    106         (sh_video->format == 0x10000002) ||
    107         (sh_video->format == mmioFOURCC('m','p','g','1')) ||
    108         (sh_video->format == mmioFOURCC('M','P','G','1')) ||
    109         (sh_video->format == mmioFOURCC('m','p','g','2')) ||
    110         (sh_video->format == mmioFOURCC('M','P','G','2')) ||
    111         (sh_video->format == mmioFOURCC('m','p','e','g')) ||
    112         (sh_video->format == mmioFOURCC('M','P','E','G')))
    113     {
    114         int saved_pos, saved_type;
    115 
    116         /* demuxer pos saving is required for libavcodec mpeg decoder as it's
    117            reading the mpeg header self! */
    118        
    119         saved_pos = d_video->buffer_pos;
    120         saved_type = d_video->demuxer->file_format;
    121 
    122         d_video->demuxer->file_format = DEMUXER_TYPE_MPEG_ES;
    123         video_read_properties(sh_video);
    124         d_video->demuxer->file_format = saved_type;
    125         d_video->buffer_pos = saved_pos;
    126 //      goto mpeg_header_parser;
    127     }
    128 #endif
    129   }
    130   break;
    131  }
    132  case VIDEO_MPEG4: {
    133    int pos = 0, vop_cnt=0, units[3];
    134    videobuf_len=0; videobuf_code_len=0;
    135    mp_msg(MSGT_DECVIDEO,MSGL_V,"Searching for Video Object Start code... ");fflush(stdout);
    136    while(1){
    137       int i=sync_video_packet(d_video);
    138       if(i<=0x11F) break; // found it!
    139       if(!i || !skip_video_packet(d_video)){
    140         mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n");
    141         return 0;
    142       }
    143    }
    144    mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\n");
    145    if(!videobuffer) {
    146      videobuffer=(char*)memalign(8,VIDEOBUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
    147      if (videobuffer) memset(videobuffer+VIDEOBUFFER_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
    148      else {
    149        mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_ShMemAllocFail);
    150        return 0;
    151      }
    152    }
    153    mp_msg(MSGT_DECVIDEO,MSGL_V,"Searching for Video Object Layer Start code... ");fflush(stdout);
    154    while(1){
    155       int i=sync_video_packet(d_video);
    156       mp_msg(MSGT_DECVIDEO,MSGL_V,"M4V: 0x%X\n",i);
    157       if(i>=0x120 && i<=0x12F) break; // found it!
    158       if(!i || !read_video_packet(d_video)){
    159         mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n");
    160         return 0;
    161       }
    162    }
    163    pos = videobuf_len+4;
    164    if(!read_video_packet(d_video)){
    165      mp_msg(MSGT_DECVIDEO,MSGL_ERR,"Can't read Video Object Layer Header\n");
    166      return 0;
    167    }
    168    mp4_header_process_vol(&picture, &(videobuffer[pos]));
    169    mp_msg(MSGT_DECVIDEO,MSGL_V,"OK! FPS SEEMS TO BE %.3f\nSearching for Video Object Plane Start code... ", sh_video->fps);fflush(stdout);
    170  mp4_init:
    171    while(1){
    172       int i=sync_video_packet(d_video);
    173       if(i==0x1B6) break; // found it!
    174       if(!i || !read_video_packet(d_video)){
    175         mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n");
    176         return 0;
    177       }
    178    }
    179    pos = videobuf_len+4;
    180    if(!read_video_packet(d_video)){
    181      mp_msg(MSGT_DECVIDEO,MSGL_ERR,"Can't read Video Object Plane Header\n");
    182      return 0;
    183    }
    184    mp4_header_process_vop(&picture, &(videobuffer[pos]));
    185    units[vop_cnt] = picture.timeinc_unit;
    186    vop_cnt++;
    187    //mp_msg(MSGT_DECVIDEO,MSGL_V, "TYPE: %d, unit: %d\n", picture.picture_type, picture.timeinc_unit);
    188    if(!picture.fps) {
    189      int i, mn, md, mx, diff;
    190      if(vop_cnt < 3)
    191           goto mp4_init;
    192 
    193      i=0;
    194      mn = mx = units[0]; 
    195      for(i=0; i<3; i++) {
    196        if(units[i] < mn)
    197          mn = units[i];
    198        if(units[i] > mx)
    199          mx = units[i];
    200      }
    201      md = mn;
    202      for(i=0; i<3; i++) {
    203        if((units[i] > mn) && (units[i] < mx))
    204          md = units[i];
    205      }
    206      mp_msg(MSGT_DECVIDEO,MSGL_V, "MIN: %d, mid: %d, max: %d\n", mn, md, mx);
    207      if(mx - md > md - mn)
    208        diff = md - mn;
    209      else
    210        diff = mx - md;
    211      if(diff > 0){
    212        picture.fps = ((float)picture.timeinc_resolution) / diff;
    213        mp_msg(MSGT_DECVIDEO,MSGL_V, "FPS seems to be: %f, resolution: %d, delta_units: %d\n", picture.fps, picture.timeinc_resolution, diff);
    214      }
    215    }
    216    if(picture.fps) {
    217     sh_video->fps=picture.fps;
    218     sh_video->frametime=1.0/picture.fps;
    219     mp_msg(MSGT_DECVIDEO,MSGL_INFO, "FPS seems to be: %f\n", picture.fps);
    220    }
    221    mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\n");
    222    sh_video->format=0x10000004;
    223    break;
    224  }
    225  case VIDEO_H264: {
    226    int pos = 0;
    227    videobuf_len=0; videobuf_code_len=0;
    228    mp_msg(MSGT_DECVIDEO,MSGL_V,"Searching for sequence parameter set... ");fflush(stdout);
    229    while(1){
    230       int i=sync_video_packet(d_video);
    231       if((i&~0x60) == 0x107 && i != 0x107) break; // found it!
    232       if(!i || !skip_video_packet(d_video)){
    233         mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n");
    234         return 0;
    235       }
    236    }
    237    mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\n");
    238    if(!videobuffer) {
    239      videobuffer=(char*)memalign(8,VIDEOBUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
    240      if (videobuffer) memset(videobuffer+VIDEOBUFFER_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
    241      else {
    242        mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_ShMemAllocFail);
    243        return 0;
    244      }
    245    }
    246    pos = videobuf_len+4;
    247    if(!read_video_packet(d_video)){
    248      mp_msg(MSGT_DECVIDEO,MSGL_ERR,"Can't read sequence parameter set\n");
    249      return 0;
    250    }
    251    h264_parse_sps(&picture, &(videobuffer[pos]), videobuf_len - pos);
    252    mp_msg(MSGT_DECVIDEO,MSGL_V,"Searching for picture parameter set... ");fflush(stdout);
    253    while(1){
    254       int i=sync_video_packet(d_video);
    255       mp_msg(MSGT_DECVIDEO,MSGL_V,"H264: 0x%X\n",i);
    256       if((i&~0x60) == 0x108 && i != 0x108) break; // found it!
    257       if(!i || !read_video_packet(d_video)){
    258         mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n");
    259         return 0;
    260       }
    261    }
    262    mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\nSearching for Slice... ");fflush(stdout);
    263    while(1){
    264       int i=sync_video_packet(d_video);
    265       if((i&~0x60) == 0x101 || (i&~0x60) == 0x102 || (i&~0x60) == 0x105) break; // found it!
    266       if(!i || !read_video_packet(d_video)){
    267         mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n");
    268         return 0;
    269       }
    270    }
    271    mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\n");
    272    sh_video->format=0x10000005;
    273    if(picture.fps) {
    274      sh_video->fps=picture.fps;
    275      sh_video->frametime=1.0/picture.fps;
    276      mp_msg(MSGT_DECVIDEO,MSGL_INFO, "FPS seems to be: %f\n", picture.fps);
    277    }
    278    break;
    279  }
    280  case VIDEO_MPEG12: {
    281 mpeg_header_parser:
    282    // Find sequence_header first:
    283    videobuf_len=0; videobuf_code_len=0;
    284    telecine=0; telecine_cnt=-2.5;
    285    mp_msg(MSGT_DECVIDEO,MSGL_V,"Searching for sequence header... ");fflush(stdout);
    286    while(1){
    287       int i=sync_video_packet(d_video);
    288       if(i==0x1B3) break; // found it!
    289       if(!i || !skip_video_packet(d_video)){
    290         if( mp_msg_test(MSGT_DECVIDEO,MSGL_V) )  mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n");
    291         mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_MpegNoSequHdr);
    292         return 0;
    293       }
    294    }
    295    mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\n");
    296 //   sh_video=d_video->sh;sh_video->ds=d_video;
    297 //   mpeg2_init();
    298    // ========= Read & process sequence header & extension ============
    299    if(!videobuffer) {
    300      videobuffer=(char*)memalign(8,VIDEOBUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
    301      if (videobuffer) memset(videobuffer+VIDEOBUFFER_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
    302      else {
    303        mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_ShMemAllocFail);
    304        return 0;
    305      }
    306    }
    307    
    308    if(!read_video_packet(d_video)){
    309      mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_CannotReadMpegSequHdr);
    310      return 0;
    311    }
    312    if(mp_header_process_sequence_header (&picture, &videobuffer[4])) {
    313      mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_BadMpegSequHdr);
    314      goto mpeg_header_parser;
    315      //return 0;
    316    }
    317    if(sync_video_packet(d_video)==0x1B5){ // next packet is seq. ext.
    318 //    videobuf_len=0;
    319     int pos=videobuf_len;
    320     if(!read_video_packet(d_video)){
    321       mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_CannotReadMpegSequHdrEx);
    322       return 0;
    323     }
    324     if(mp_header_process_extension (&picture, &videobuffer[pos+4])) {
    325       mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_BadMpegSequHdrEx);
    326       return 0;
    327     }
    328    }
    329    
    330 //   printf("picture.fps=%d\n",picture.fps);
    331    // display info:
    332    sh_video->format=picture.mpeg1?0x10000001:0x10000002; // mpeg video
    333    sh_video->fps=picture.fps;
    334    if(!sh_video->fps){
    335 //     if(!force_fps){
    336 //       fprintf(stderr,"FPS not specified (or invalid) in the header! Use the -fps option!\n");
    337 //       return 0;
    338 //     }
    339      sh_video->frametime=0;
    340    } else {
    341      sh_video->frametime=1.0/picture.fps;
    342    }
    343    sh_video->disp_w=picture.display_picture_width;
    344    sh_video->disp_h=picture.display_picture_height;
    345    // bitrate:
    346    if(picture.bitrate!=0x3FFFF) // unspecified/VBR ?
    347        sh_video->i_bps=picture.bitrate * 400 / 8;
    348    // info:
    349    mp_dbg(MSGT_DECVIDEO,MSGL_DBG2,"mpeg bitrate: %d (%X)\n",picture.bitrate,picture.bitrate);
    350    mp_msg(MSGT_DECVIDEO,MSGL_INFO,"VIDEO:  %s  %dx%d  (aspect %d)  %5.3f fps  %5.1f kbps (%4.1f kbyte/s)\n",
    351     picture.mpeg1?"MPEG1":"MPEG2",
    352     sh_video->disp_w,sh_video->disp_h,
    353     picture.aspect_ratio_information,
    354     sh_video->fps,
    355     sh_video->i_bps * 8 / 1000.0,
    356     sh_video->i_bps / 1000.0 );
    357   break;
    358  }
    359 } // switch(file_format)
    360 
    361 return 1;
     108            /* hack to support decoding of mpeg1 chunks in AVI's with libmpeg2 -- 2002 alex */
     109            if ((sh_video->format == 0x10000001) ||
     110                (sh_video->format == 0x10000002) ||
     111                (sh_video->format == mmioFOURCC('m','p','g','1')) ||
     112                (sh_video->format == mmioFOURCC('M','P','G','1')) ||
     113                (sh_video->format == mmioFOURCC('m','p','g','2')) ||
     114                (sh_video->format == mmioFOURCC('M','P','G','2')) ||
     115                (sh_video->format == mmioFOURCC('m','p','e','g')) ||
     116                (sh_video->format == mmioFOURCC('M','P','E','G')))
     117            {
     118                int saved_pos, saved_type;
     119
     120                /* demuxer pos saving is required for libavcodec mpeg decoder as it's
     121                 reading the mpeg header self! */
     122
     123                saved_pos = d_video->buffer_pos;
     124                saved_type = d_video->demuxer->file_format;
     125
     126                d_video->demuxer->file_format = DEMUXER_TYPE_MPEG_ES;
     127                video_read_properties(sh_video);
     128                d_video->demuxer->file_format = saved_type;
     129                d_video->buffer_pos = saved_pos;
     130                //      goto mpeg_header_parser;
     131            }
     132#endif
     133        }
     134        break;
     135    }
     136    case VIDEO_MPEG4: {
     137        int pos = 0, vop_cnt=0, units[3];
     138        videobuf_len=0; videobuf_code_len=0;
     139        mp_msg(MSGT_DECVIDEO,MSGL_V,"Searching for Video Object Start code... ");fflush(stdout);
     140        while(1){
     141            int i=sync_video_packet(d_video);
     142            if(i<=0x11F) break; // found it!
     143            if(!i || !skip_video_packet(d_video)){
     144                mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n");
     145                return 0;
     146            }
     147        }
     148        mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\n");
     149        if(!videobuffer) {
     150            videobuffer=(char*)memalign(8,VIDEOBUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
     151            if (videobuffer) memset(videobuffer+VIDEOBUFFER_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
     152            else {
     153                mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_ShMemAllocFail);
     154                return 0;
     155            }
     156        }
     157        mp_msg(MSGT_DECVIDEO,MSGL_V,"Searching for Video Object Layer Start code... ");fflush(stdout);
     158        while(1){
     159            int i=sync_video_packet(d_video);
     160            mp_msg(MSGT_DECVIDEO,MSGL_V,"M4V: 0x%X\n",i);
     161            if(i>=0x120 && i<=0x12F) break; // found it!
     162            if(!i || !read_video_packet(d_video)){
     163                mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n");
     164                return 0;
     165            }
     166        }
     167        pos = videobuf_len+4;
     168        if(!read_video_packet(d_video)){
     169            mp_msg(MSGT_DECVIDEO,MSGL_ERR,"Can't read Video Object Layer Header\n");
     170            return 0;
     171        }
     172        mp4_header_process_vol(&picture, &(videobuffer[pos]));
     173        mp_msg(MSGT_DECVIDEO,MSGL_V,"OK! FPS SEEMS TO BE %.3f\nSearching for Video Object Plane Start code... ", sh_video->fps);fflush(stdout);
     174    mp4_init:
     175        while(1){
     176            int i=sync_video_packet(d_video);
     177            if(i==0x1B6) break; // found it!
     178            if(!i || !read_video_packet(d_video)){
     179                mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n");
     180                return 0;
     181            }
     182        }
     183        pos = videobuf_len+4;
     184        if(!read_video_packet(d_video)){
     185            mp_msg(MSGT_DECVIDEO,MSGL_ERR,"Can't read Video Object Plane Header\n");
     186            return 0;
     187        }
     188        mp4_header_process_vop(&picture, &(videobuffer[pos]));
     189        units[vop_cnt] = picture.timeinc_unit;
     190        vop_cnt++;
     191        //mp_msg(MSGT_DECVIDEO,MSGL_V, "TYPE: %d, unit: %d\n", picture.picture_type, picture.timeinc_unit);
     192        if(!picture.fps) {
     193            int i, mn, md, mx, diff;
     194            if(vop_cnt < 3)
     195                goto mp4_init;
     196
     197            i=0;
     198            mn = mx = units[0];
     199            for(i=0; i<3; i++) {
     200                if(units[i] < mn)
     201                    mn = units[i];
     202                if(units[i] > mx)
     203                    mx = units[i];
     204            }
     205            md = mn;
     206            for(i=0; i<3; i++) {
     207                if((units[i] > mn) && (units[i] < mx))
     208                    md = units[i];
     209            }
     210            mp_msg(MSGT_DECVIDEO,MSGL_V, "MIN: %d, mid: %d, max: %d\n", mn, md, mx);
     211            if(mx - md > md - mn)
     212                diff = md - mn;
     213            else
     214                diff = mx - md;
     215            if(diff > 0){
     216                picture.fps = ((float)picture.timeinc_resolution) / diff;
     217                mp_msg(MSGT_DECVIDEO,MSGL_V, "FPS seems to be: %f, resolution: %d, delta_units: %d\n", picture.fps, picture.timeinc_resolution, diff);
     218            }
     219        }
     220        if(picture.fps) {
     221            sh_video->fps=picture.fps;
     222            sh_video->frametime=1.0/picture.fps;
     223            mp_msg(MSGT_DECVIDEO,MSGL_INFO, "FPS seems to be: %f\n", picture.fps);
     224        }
     225        mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\n");
     226        sh_video->format=0x10000004;
     227        break;
     228    }
     229    case VIDEO_H264: {
     230        int pos = 0;
     231        videobuf_len=0; videobuf_code_len=0;
     232        mp_msg(MSGT_DECVIDEO,MSGL_V,"Searching for sequence parameter set... ");fflush(stdout);
     233        while(1){
     234            int i=sync_video_packet(d_video);
     235            if((i&~0x60) == 0x107 && i != 0x107) break; // found it!
     236            if(!i || !skip_video_packet(d_video)){
     237                mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n");
     238                return 0;
     239            }
     240        }
     241        mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\n");
     242        if(!videobuffer) {
     243            videobuffer=(char*)memalign(8,VIDEOBUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
     244            if (videobuffer) memset(videobuffer+VIDEOBUFFER_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
     245            else {
     246                mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_ShMemAllocFail);
     247                return 0;
     248            }
     249        }
     250        pos = videobuf_len+4;
     251        if(!read_video_packet(d_video)){
     252            mp_msg(MSGT_DECVIDEO,MSGL_ERR,"Can't read sequence parameter set\n");
     253            return 0;
     254        }
     255        h264_parse_sps(&picture, &(videobuffer[pos]), videobuf_len - pos);
     256        mp_msg(MSGT_DECVIDEO,MSGL_V,"Searching for picture parameter set... ");fflush(stdout);
     257        while(1){
     258            int i=sync_video_packet(d_video);
     259            mp_msg(MSGT_DECVIDEO,MSGL_V,"H264: 0x%X\n",i);
     260            if((i&~0x60) == 0x108 && i != 0x108) break; // found it!
     261            if(!i || !read_video_packet(d_video)){
     262                mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n");
     263                return 0;
     264            }
     265        }
     266        mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\nSearching for Slice... ");fflush(stdout);
     267        while(1){
     268            int i=sync_video_packet(d_video);
     269            if((i&~0x60) == 0x101 || (i&~0x60) == 0x102 || (i&~0x60) == 0x105) break; // found it!
     270            if(!i || !read_video_packet(d_video)){
     271                mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n");
     272                return 0;
     273            }
     274        }
     275        mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\n");
     276        sh_video->format=0x10000005;
     277        if(picture.fps) {
     278            sh_video->fps=picture.fps;
     279            sh_video->frametime=1.0/picture.fps;
     280            mp_msg(MSGT_DECVIDEO,MSGL_INFO, "FPS seems to be: %f\n", picture.fps);
     281        }
     282        break;
     283    }
     284    case VIDEO_MPEG12: {
     285    mpeg_header_parser:
     286        // Find sequence_header first:
     287        videobuf_len=0; videobuf_code_len=0;
     288        telecine=0; telecine_cnt=-2.5;
     289        mp_msg(MSGT_DECVIDEO,MSGL_V,"Searching for sequence header... ");fflush(stdout);
     290        while(1){
     291            int i=sync_video_packet(d_video);
     292            if(i==0x1B3) break; // found it!
     293            if(!i || !skip_video_packet(d_video)){
     294                if( mp_msg_test(MSGT_DECVIDEO,MSGL_V) )  mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n");
     295                mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_MpegNoSequHdr);
     296                return 0;
     297            }
     298        }
     299        mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\n");
     300        //   sh_video=d_video->sh;sh_video->ds=d_video;
     301        //   mpeg2_init();
     302        // ========= Read & process sequence header & extension ============
     303        if(!videobuffer) {
     304            videobuffer=(char*)memalign(8,VIDEOBUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
     305            if (videobuffer) memset(videobuffer+VIDEOBUFFER_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
     306            else {
     307                mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_ShMemAllocFail);
     308                return 0;
     309            }
     310        }
     311
     312        if(!read_video_packet(d_video)){
     313            mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_CannotReadMpegSequHdr);
     314            return 0;
     315        }
     316        if(mp_header_process_sequence_header (&picture, &videobuffer[4])) {
     317            mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_BadMpegSequHdr);
     318            goto mpeg_header_parser;
     319            //return 0;
     320        }
     321        if(sync_video_packet(d_video)==0x1B5){ // next packet is seq. ext.
     322            //    videobuf_len=0;
     323            int pos=videobuf_len;
     324            if(!read_video_packet(d_video)){
     325                mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_CannotReadMpegSequHdrEx);
     326                return 0;
     327            }
     328            if(mp_header_process_extension (&picture, &videobuffer[pos+4])) {
     329                mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_BadMpegSequHdrEx);
     330                return 0;
     331            }
     332        }
     333
     334        //   printf("picture.fps=%d\n",picture.fps);
     335        // display info:
     336        sh_video->format=picture.mpeg1?0x10000001:0x10000002; // mpeg video
     337        sh_video->fps=picture.fps;
     338        if(!sh_video->fps){
     339            //     if(!force_fps){
     340            //       fprintf(stderr,"FPS not specified (or invalid) in the header! Use the -fps option!\n");
     341            //       return 0;
     342            //     }
     343            sh_video->frametime=0;
     344        } else {
     345            sh_video->frametime=1.0/picture.fps;
     346        }
     347        sh_video->disp_w=picture.display_picture_width;
     348        sh_video->disp_h=picture.display_picture_height;
     349        // bitrate:
     350        if(picture.bitrate!=0x3FFFF) // unspecified/VBR ?
     351            sh_video->i_bps=picture.bitrate * 400 / 8;
     352        // info:
     353        mp_dbg(MSGT_DECVIDEO,MSGL_DBG2,"mpeg bitrate: %d (%X)\n",picture.bitrate,picture.bitrate);
     354        mp_msg(MSGT_DECVIDEO,MSGL_INFO,"VIDEO:  %s  %dx%d  (aspect %d)  %5.3f fps  %5.1f kbps (%4.1f kbyte/s)\n",
     355               picture.mpeg1?"MPEG1":"MPEG2",
     356               sh_video->disp_w,sh_video->disp_h,
     357               picture.aspect_ratio_information,
     358               sh_video->fps,
     359               sh_video->i_bps * 8 / 1000.0,
     360               sh_video->i_bps / 1000.0 );
     361        break;
     362    }
     363    } // switch(file_format)
     364
     365    return 1;
    362366}
    363367
    … …  
    368372    /* if the user data starts with "CC", assume it is a CC info packet */
    369373    if(len>2 && buf[0]=='C' && buf[1]=='C'){
    370 //      mp_msg(MSGT_DECVIDEO,MSGL_DBG2,"video.c: process_userdata() detected Closed Captions!\n");
    371         subcc_process_data(buf+2,len-2);
     374        //      mp_msg(MSGT_DECVIDEO,MSGL_DBG2,"video.c: process_userdata() detected Closed Captions!\n");
     375        subcc_process_data(buf+2,len-2);
    372376    }
    373377    if( len > 2 && buf[ 0 ] == 'T' && buf[ 1 ] == 'Y' )
    374378    {
    375        //ty_processuserdata( buf + 2, len - 2 );
    376        return;
     379        //ty_processuserdata( buf + 2, len - 2 );
     380        return;
    377381    }
    378382    if(verbose<2) return;
    379383    printf( "user_data: len=%3d  %02X %02X %02X %02X '",
    380             len, buf[0], buf[1], buf[2], buf[3]);
     384           len, buf[0], buf[1], buf[2], buf[3]);
    381385    for(i=0;i<len;i++)
    382 //      if(buf[i]>=32 && buf[i]<127) putchar(buf[i]);
    383         if(buf[i]&0x60) putchar(buf[i]&0x7F);
     386        //      if(buf[i]>=32 && buf[i]<127) putchar(buf[i]);
     387        if(buf[i]&0x60) putchar(buf[i]&0x7F);
    384388    printf("'\n");
    385389}
    … …  
    392396    float pts=0;
    393397    int picture_coding_type=0;
    394 //    unsigned char* start=NULL;
     398    //    unsigned char* start=NULL;
    395399    int in_size=0;
    396    
     400
    397401    *start=NULL;
    398402
    399   if(demuxer->file_format==DEMUXER_TYPE_MPEG_ES ||
    400      demuxer->file_format==DEMUXER_TYPE_MPEG_GXF ||
    401      demuxer->file_format==DEMUXER_TYPE_MPEG_PES ||
    402         (demuxer->file_format==DEMUXER_TYPE_MPEG_PS && ((! sh_video->format) || (sh_video->format==0x10000001) || (sh_video->format==0x10000002)))
    403                   || demuxer->file_format==DEMUXER_TYPE_PVA ||
    404                   ((demuxer->file_format==DEMUXER_TYPE_MPEG_TS) && ((sh_video->format==0x10000001) || (sh_video->format==0x10000002)))
    405                   || demuxer->file_format==DEMUXER_TYPE_MPEG_TY
     403    if(demuxer->file_format==DEMUXER_TYPE_MPEG_ES ||
     404       demuxer->file_format==DEMUXER_TYPE_MPEG_GXF ||
     405       demuxer->file_format==DEMUXER_TYPE_MPEG_PES ||
     406       (demuxer->file_format==DEMUXER_TYPE_MPEG_PS && ((! sh_video->format) || (sh_video->format==0x10000001) || (sh_video->format==0x10000002)))
     407       || demuxer->file_format==DEMUXER_TYPE_PVA ||
     408       ((demuxer->file_format==DEMUXER_TYPE_MPEG_TS) && ((sh_video->format==0x10000001) || (sh_video->format==0x10000002)))
     409       || demuxer->file_format==DEMUXER_TYPE_MPEG_TY
    406410#ifdef STREAMING_LIVE555
    407     || (demuxer->file_format==DEMUXER_TYPE_RTP && demux_is_mpeg_rtp_stream(demuxer))
    408 #endif
    409   ){
     411       || (demuxer->file_format==DEMUXER_TYPE_RTP && demux_is_mpeg_rtp_stream(demuxer))
     412#endif
     413      ){
    410414        int in_frame=0;
    411415        //float newfps;
    412416        //videobuf_len=0;
    413417        while(videobuf_len<VIDEOBUFFER_SIZE-MAX_VIDEO_PACKET_SIZE){
    414           int i=sync_video_packet(d_video);
    415           //void* buffer=&videobuffer[videobuf_len+4];
    416           int start=videobuf_len+4;
    417           if(in_frame){
    418             if(i<0x101 || i>=0x1B0){  // not slice code -> end of frame
     418            int i=sync_video_packet(d_video);
     419            //void* buffer=&videobuffer[videobuf_len+4];
     420            int start=videobuf_len+4;
     421            if(in_frame){
     422                if(i<0x101 || i>=0x1B0){  // not slice code -> end of frame
    419423#if 0
    420               // send END OF FRAME code:
    421               videobuffer[videobuf_len+0]=0;
    422               videobuffer[videobuf_len+1]=0;
    423               videobuffer[videobuf_len+2]=1;
    424               videobuffer[videobuf_len+3]=0xFF;
    425               videobuf_len+=4;
    426 #endif
    427               if(!i) return -1; // EOF
    428               break;
    429             }
    430           } else {
    431             if(i==0x100){
    432                 pts=d_video->pts;
    433                 d_video->pts=0;
    434             }
    435             //if(i==0x100) in_frame=1; // picture startcode
    436             if(i>=0x101 && i<0x1B0) in_frame=1; // picture startcode
    437             else if(!i) return -1; // EOF
    438           }
    439           //if(grab_frames==2 && (i==0x1B3 || i==0x1B8)) grab_frames=1;
    440           if(!read_video_packet(d_video)) return -1; // EOF
    441           //printf("read packet 0x%X, len=%d\n",i,videobuf_len);
    442           // process headers:
    443           switch(i){
    444               case 0x1B3: mp_header_process_sequence_header (&picture, &videobuffer[start]);break;
    445               case 0x1B5: mp_header_process_extension (&picture, &videobuffer[start]);break;
    446               case 0x1B2: process_userdata (&videobuffer[start], videobuf_len-start);break;
    447               case 0x100: picture_coding_type=(videobuffer[start+1] >> 3) & 7;break;
    448           }
    449         }
    450        
     424                    // send END OF FRAME code:
     425                    videobuffer[videobuf_len+0]=0;
     426                    videobuffer[videobuf_len+1]=0;
     427                    videobuffer[videobuf_len+2]=1;
     428                    videobuffer[videobuf_len+3]=0xFF;
     429                    videobuf_len+=4;
     430#endif
     431                    if(!i) return -1; // EOF
     432                    break;
     433                }
     434            } else {
     435                if(i==0x100){
     436                    pts=d_video->pts;
     437                    d_video->pts=0;
     438                }
     439                //if(i==0x100) in_frame=1; // picture startcode
     440                if(i>=0x101 && i<0x1B0) in_frame=1; // picture startcode
     441                else if(!i) return -1; // EOF
     442            }
     443            //if(grab_frames==2 && (i==0x1B3 || i==0x1B8)) grab_frames=1;
     444            if(!read_video_packet(d_video)) return -1; // EOF
     445            // process headers:
     446            switch(i){
     447            case 0x1B3: mp_header_process_sequence_header (&picture, &videobuffer[start]);break;
     448            case 0x1B5: mp_header_process_extension (&picture, &videobuffer[start]);break;
     449            case 0x1B2: process_userdata (&videobuffer[start], videobuf_len-start);break;
     450            case 0x100: picture_coding_type=(videobuffer[start+1] >> 3) & 7;break;
     451            }
     452        }
     453
    451454        // if(videobuf_len>max_framesize) max_framesize=videobuf_len; // debug
    452455        //printf("--- SEND %d bytes\n",videobuf_len);
    453 //      if(grab_frames==1){
    454 //            FILE *f=fopen("grab.mpg","ab");
    455 //            fwrite(videobuffer,videobuf_len-4,1,f);
    456 //            fclose(f);
    457 //      }
    458 
    459         *start=videobuffer; in_size=videobuf_len;
    460         //blit_frame=decode_video(video_out,sh_video,videobuffer,videobuf_len,drop_frame);
     456        //      if(grab_frames==1){
     457        //            FILE *f=fopen("grab.mpg","ab");
     458        //            fwrite(videobuffer,videobuf_len-4,1,f);
     459        //            fclose(f);
     460        //      }
     461
     462        *start=videobuffer; in_size=videobuf_len;
     463        //blit_frame=decode_video(video_out,sh_video,videobuffer,videobuf_len,drop_frame);
    461464
    462465#if 1
    463     // get mpeg fps:
    464     //newfps=frameratecode2framerate[picture->frame_rate_code]*0.0001f;
    465     if(sh_video->fps!=picture.fps) if(!force_fps && !telecine){
     466        // get mpeg fps:
     467        //newfps=frameratecode2framerate[picture->frame_rate_code]*0.0001f;
     468        if(sh_video->fps!=picture.fps) if(!force_fps && !telecine){
    466469            mp_msg(MSGT_CPLAYER,MSGL_WARN,"Warning! FPS changed %5.3f -> %5.3f  (%f) [%d]  \n",sh_video->fps,picture.fps,sh_video->fps-picture.fps,picture.frame_rate_code);
    467470            sh_video->fps=picture.fps;
    468471            sh_video->frametime=1.0/picture.fps;
    469     }
    470 #endif
    471 
    472     // fix mpeg2 frametime:
    473     frame_time=(picture.display_time)*0.01f;
    474     picture.display_time=100;
    475     videobuf_len=0;
    476 
    477     telecine_cnt*=0.9; // drift out error
    478     telecine_cnt+=frame_time-5.0/4.0;
    479     mp_msg(MSGT_DECVIDEO,MSGL_DBG2,"\r telecine = %3.1f  %5.3f     \n",frame_time,telecine_cnt);
    480    
    481     if(telecine){
    482         frame_time=1;
    483         if(telecine_cnt<-1.5 || telecine_cnt>1.5){
    484             mp_msg(MSGT_DECVIDEO,MSGL_INFO,MSGTR_LeaveTelecineMode);
    485             telecine=0;
    486         }
    487     } else
    488         if(telecine_cnt>-0.5 && telecine_cnt<0.5 && !force_fps){
    489             sh_video->fps=sh_video->fps*4/5;
    490             sh_video->frametime=sh_video->frametime*5/4;
    491             mp_msg(MSGT_DECVIDEO,MSGL_INFO,MSGTR_EnterTelecineMode);
    492             telecine=1;
    493         }
    494 
    495   } else if((demuxer->file_format==DEMUXER_TYPE_MPEG4_ES) || ((demuxer->file_format==DEMUXER_TYPE_MPEG_TS) && (sh_video->format==0x10000004)) ||
    496             ((demuxer->file_format==DEMUXER_TYPE_MPEG_PS) && (sh_video->format==0x10000004))
    497   ){
    498       //
     472        }
     473#endif
     474
     475        // fix mpeg2 frametime:
     476        frame_time=(picture.display_time)*0.01f;
     477        picture.display_time=100;
     478        videobuf_len=0;
     479
     480        telecine_cnt*=0.9; // drift out error
     481        telecine_cnt+=frame_time-5.0/4.0;
     482        mp_msg(MSGT_DECVIDEO,MSGL_DBG2,"\r telecine = %3.1f  %5.3f     \n",frame_time,telecine_cnt);
     483
     484        if(telecine){
     485            frame_time=1;
     486            if(telecine_cnt<-1.5 || telecine_cnt>1.5){
     487                mp_msg(MSGT_DECVIDEO,MSGL_INFO,MSGTR_LeaveTelecineMode);
     488                telecine=0;
     489            }
     490        } else
     491            if(telecine_cnt>-0.5 && telecine_cnt<0.5 && !force_fps){
     492                sh_video->fps=sh_video->fps*4/5;
     493                sh_video->frametime=sh_video->frametime*5/4;
     494                mp_msg(MSGT_DECVIDEO,MSGL_INFO,MSGTR_EnterTelecineMode);
     495                telecine=1;
     496            }
     497
     498    } else if((demuxer->file_format==DEMUXER_TYPE_MPEG4_ES) || ((demuxer->file_format==DEMUXER_TYPE_MPEG_TS) && (sh_video->format==0x10000004)) ||
     499              ((demuxer->file_format==DEMUXER_TYPE_MPEG_PS) && (sh_video->format==0x10000004))
     500             ){
     501        //
    499502        while(videobuf_len<VIDEOBUFFER_SIZE-MAX_VIDEO_PACKET_SIZE){
    500           int i=sync_video_packet(d_video);
    501           if(!i) return -1;
    502           if(!read_video_packet(d_video)) return -1; // EOF
    503           if(i==0x1B6) break;
    504         }
    505         *start=videobuffer; in_size=videobuf_len;
    506         videobuf_len=0;
    507 
    508   } else if(demuxer->file_format==DEMUXER_TYPE_H264_ES || ((demuxer->file_format==DEMUXER_TYPE_MPEG_TS) && (sh_video->format==0x10000005)) ||
    509             ((demuxer->file_format==DEMUXER_TYPE_MPEG_PS) && (sh_video->format==0x10000005))
    510   ){
    511       //
     503            int i=sync_video_packet(d_video);
     504            if(!i) return -1;
     505            if(!read_video_packet(d_video)) return -1; // EOF
     506            if(i==0x1B6) break;
     507        }
     508        *start=videobuffer; in_size=videobuf_len;
     509        videobuf_len=0;
     510
     511    } else if(demuxer->file_format==DEMUXER_TYPE_H264_ES || ((demuxer->file_format==DEMUXER_TYPE_MPEG_TS) && (sh_video->format==0x10000005)) ||
     512              ((demuxer->file_format==DEMUXER_TYPE_MPEG_PS) && (sh_video->format==0x10000005))
     513             ){
     514        //
    512515        int in_picture = 0;
    513516        while(videobuf_len<VIDEOBUFFER_SIZE-MAX_VIDEO_PACKET_SIZE){
    514           int i=sync_video_packet(d_video);
    515           int pos = videobuf_len+4;
    516           if(!i) return -1;
    517           if(!read_video_packet(d_video)) return -1; // EOF
    518           if((i&~0x60) == 0x107 && i != 0x107) {
    519             h264_parse_sps(&picture, &(videobuffer[pos]), videobuf_len - pos);
    520             if(picture.fps > 0) {
    521               sh_video->fps=picture.fps;
    522               sh_video->frametime=1.0/picture.fps;
    523             }
    524             i=sync_video_packet(d_video);
     517            int i=sync_video_packet(d_video);
     518            int pos = videobuf_len+4;
    525519            if(!i) return -1;
    526520            if(!read_video_packet(d_video)) return -1; // EOF
    527           }
    528 
    529           // here starts the access unit end detection code
    530           // see the mail on MPlayer-dev-eng for details:
    531           // Date: Sat, 17 Sep 2005 11:24:06 +0200
    532           // Subject: Re: [MPlayer-dev-eng] [RFC] h264 ES parser problems
    533           // Message-ID: <20050917092406.GA7699@rz.uni-karlsruhe.de>
    534           if((i&~0x60) == 0x101 || (i&~0x60) == 0x102 || (i&~0x60) == 0x105)
    535             // found VCL NAL with slice header i.e. start of current primary coded
    536             // picture, so start scanning for the end now
    537             in_picture = 1;
    538           if (in_picture) {
    539             i = sync_video_packet(d_video) & ~0x60; // code of next packet
    540             if(i == 0x106 || i == 0x109) break; // SEI or access unit delim.
    541             if(i == 0x101 || i == 0x102 || i == 0x105) {
    542               // assuming arbitrary slice ordering is not allowed, the
    543               // first_mb_in_slice (golomb encoded) value should be 0 then
    544               // for the first VCL NAL in a picture
    545               if (demux_peekc(d_video) & 0x80)
    546                 break;
    547             }
    548           }
    549         }
    550         *start=videobuffer; in_size=videobuf_len;
    551         videobuf_len=0;
    552 
    553   } else {
    554       // frame-based file formats: (AVI,ASF,MOV)
    555     in_size=ds_get_packet(d_video,start);
    556     if(in_size<0) return -1; // EOF
    557 //    if(in_size>max_framesize) max_framesize=in_size;
    558 //    blit_frame=decode_video(video_out,sh_video,start,in_size,drop_frame);
    559   }
    560 
    561 //  vdecode_time=video_time_usage-vdecode_time;
    562 
    563 //------------------------ frame decoded. --------------------
     521            if((i&~0x60) == 0x107 && i != 0x107) {
     522                h264_parse_sps(&picture, &(videobuffer[pos]), videobuf_len - pos);
     523                if(picture.fps > 0) {
     524                    sh_video->fps=picture.fps;
     525                    sh_video->frametime=1.0/picture.fps;
     526                }
     527                i=sync_video_packet(d_video);
     528                if(!i) return -1;
     529                if(!read_video_packet(d_video)) return -1; // EOF
     530            }
     531
     532            // here starts the access unit end detection code
     533            // see the mail on MPlayer-dev-eng for details:
     534            // Date: Sat, 17 Sep 2005 11:24:06 +0200
     535            // Subject: Re: [MPlayer-dev-eng] [RFC] h264 ES parser problems
     536            // Message-ID: <20050917092406.GA7699@rz.uni-karlsruhe.de>
     537            if((i&~0x60) == 0x101 || (i&~0x60) == 0x102 || (i&~0x60) == 0x105)
     538                // found VCL NAL with slice header i.e. start of current primary coded
     539                // picture, so start scanning for the end now
     540                in_picture = 1;
     541            if (in_picture) {
     542                i = sync_video_packet(d_video) & ~0x60; // code of next packet
     543                if(i == 0x106 || i == 0x109) break; // SEI or access unit delim.
     544                if(i == 0x101 || i == 0x102 || i == 0x105) {
     545                    // assuming arbitrary slice ordering is not allowed, the
     546                    // first_mb_in_slice (golomb encoded) value should be 0 then
     547                    // for the first VCL NAL in a picture
     548                    if (demux_peekc(d_video) & 0x80)
     549                        break;
     550                }
     551            }
     552        }
     553        *start=videobuffer; in_size=videobuf_len;
     554        videobuf_len=0;
     555
     556    } else {
     557        // frame-based file formats: (AVI,ASF,MOV)
     558        in_size=ds_get_packet(d_video,start);
     559        if(in_size<0) return -1; // EOF
     560        //    if(in_size>max_framesize) max_framesize=in_size;
     561        //    blit_frame=decode_video(video_out,sh_video,start,in_size,drop_frame);
     562    }
     563
     564    //  vdecode_time=video_time_usage-vdecode_time;
     565
     566    //------------------------ frame decoded. --------------------
    564567
    565568    // Increase video timers:
    … …  
    571574    // override frame_time for variable/unknown FPS formats:
    572575    if(!force_fps) switch(demuxer->file_format){
    573       case DEMUXER_TYPE_GIF:
    574       case DEMUXER_TYPE_MATROSKA:
    575         if(d_video->pts>0 && pts1>0 && d_video->pts>pts1)
    576           frame_time=d_video->pts-pts1;
     576    case DEMUXER_TYPE_GIF:
     577    case DEMUXER_TYPE_MATROSKA:
     578        if(d_video->pts>0 && pts1>0 && d_video->pts>pts1)
     579            frame_time=d_video->pts-pts1;
    577580        break;
    578581#ifdef USE_TV
    579       case DEMUXER_TYPE_TV:
    580 #endif
    581       case DEMUXER_TYPE_MOV:
    582       case DEMUXER_TYPE_FILM:
    583       case DEMUXER_TYPE_VIVO:
    584       case DEMUXER_TYPE_OGG:
    585       case DEMUXER_TYPE_ASF: {
     582    case DEMUXER_TYPE_TV:
     583#endif
     584    case DEMUXER_TYPE_MOV:
     585    case DEMUXER_TYPE_FILM:
     586    case DEMUXER_TYPE_VIVO:
     587    case DEMUXER_TYPE_OGG:
     588    case DEMUXER_TYPE_ASF: {
    586589        float next_pts = ds_get_next_pts(d_video);
    587590        float d= next_pts > 0 ? next_pts - d_video->pts : d_video->pts-pts1;
    588591        if(d>=0){
    589           if(d>0){
    590             if((int)sh_video->fps==1000)
    591               mp_msg(MSGT_CPLAYER,MSGL_V,"\navg. framerate: %d fps             \n",(int)(1.0f/d));
    592             sh_video->frametime=d; // 1ms
    593             sh_video->fps=1.0f/d;
    594           }
    595           frame_time = d;
     592            if(d>0){
     593                if((int)sh_video->fps==1000)
     594                    mp_msg(MSGT_CPLAYER,MSGL_V,"\navg. framerate: %d fps             \n",(int)(1.0f/d));
     595                sh_video->frametime=d; // 1ms
     596                sh_video->fps=1.0f/d;
     597            }
     598            frame_time = d;
    596599        } else {
    597           mp_msg(MSGT_CPLAYER,MSGL_WARN,"\nInvalid frame duration value (%5.3f/%5.3f => %5.3f). Defaulting to %5.3f sec.\n",d_video->pts,next_pts,d,frame_time);
    598           // frame_time = 1/25.0;
    599         }
    600       }
    601       break;
    602       case DEMUXER_TYPE_LAVF:
     600            mp_msg(MSGT_CPLAYER,MSGL_WARN,"\nInvalid frame duration value (%5.3f/%5.3f => %5.3f). Defaulting to %5.3f sec.\n",d_video->pts,next_pts,d,frame_time);
     601            // frame_time = 1/25.0;
     602        }
     603    }
     604    break;
     605    case DEMUXER_TYPE_LAVF:
    603606        if((int)sh_video->fps==1000 || (int)sh_video->fps<=1){
    604           float next_pts = ds_get_next_pts(d_video);
    605           float d= next_pts > 0 ? next_pts - d_video->pts : d_video->pts-pts1;
    606           if(d>=0){
    607             frame_time = d;
    608           }
    609         }
    610       break;
    611       case DEMUXER_TYPE_REAL:
     607            float next_pts = ds_get_next_pts(d_video);
     608            float d= next_pts > 0 ? next_pts - d_video->pts : d_video->pts-pts1;
     609            if(d>=0){
     610                frame_time = d;
     611            }
     612        }
     613        break;
     614    case DEMUXER_TYPE_REAL:
    612615        {
    613           double next_pts = ds_get_next_pts(d_video);
    614           float d = next_pts > 0 ? next_pts - d_video->pts : d_video->pts - pts1;
    615 
    616           frame_time = (d >= 0 && pts1 > 0) ? d : 0.001;
    617         }
    618       break;
    619     }
    620    
     616            double next_pts = ds_get_next_pts(d_video);
     617            float d = next_pts > 0 ? next_pts - d_video->pts : d_video->pts - pts1;
     618
     619            frame_time = (d >= 0 && pts1 > 0) ? d : 0.001;
     620        }
     621        break;
     622    }
     623
    621624    if(demuxer->file_format==DEMUXER_TYPE_MPEG_PS ||
    622625       demuxer->file_format==DEMUXER_TYPE_MPEG_PES ||
    … …  
    625628       demuxer->file_format==DEMUXER_TYPE_MPEG_TY){
    626629
    627 //      if(pts>0.0001) printf("\r!!! pts: %5.3f [%d] (%5.3f)   \n",pts,picture_coding_type,i_pts);
    628 
    629         sh_video->pts+=frame_time;
    630         if(picture_coding_type<=2 && sh_video->i_pts){
    631 //          printf("XXX predict: %5.3f pts: %5.3f error=%5.5f   \n",i_pts,d_video->pts2,i_pts-d_video->pts2);
    632             sh_video->pts=sh_video->i_pts;
    633             sh_video->i_pts=pts;
    634         } else {
    635             if(pts){
    636                 if(picture_coding_type<=2) sh_video->i_pts=pts;
    637                 else {
    638 //                  printf("BBB predict: %5.3f pts: %5.3f error=%5.5f   \n",pts,d_video->pts2,pts-d_video->pts2);
    639                     sh_video->pts=pts;
    640                 }
    641             }
    642         }
    643 //      printf("\rIII pts: %5.3f [%d] (%5.3f)   \n",d_video->pts2,picture_coding_type,i_pts);
     630        //      if(pts>0.0001) printf("\r!!! pts: %5.3f [%d] (%5.3f)   \n",pts,picture_coding_type,i_pts);
     631
     632        sh_video->pts+=frame_time;
     633        if(picture_coding_type<=2 && sh_video->i_pts){
     634            //      printf("XXX predict: %5.3f pts: %5.3f error=%5.5f   \n",i_pts,d_video->pts2,i_pts-d_video->pts2);
     635            sh_video->pts=sh_video->i_pts;
     636            sh_video->i_pts=pts;
     637        } else {
     638            if(pts){
     639                if(picture_coding_type<=2) sh_video->i_pts=pts;
     640                else {
     641                    //              printf("BBB predict: %5.3f pts: %5.3f error=%5.5f   \n",pts,d_video->pts2,pts-d_video->pts2);
     642                    sh_video->pts=pts;
     643                }
     644            }
     645        }
     646        //      printf("\rIII pts: %5.3f [%d] (%5.3f)   \n",d_video->pts2,picture_coding_type,i_pts);
    644647    } else
    645         sh_video->pts=d_video->pts;
    646    
     648        sh_video->pts=d_video->pts;
     649
    647650    if(frame_time_ptr) *frame_time_ptr=frame_time;
    648651    return in_size;

  • TabularUnified trunk/libswscale/rgb2rgb.c

    r261 r269  
    2323 * along with FFmpeg; if not, write to the Free Software
    2424 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
     25 *
     26 * the C code (not assembly, mmx, ...) of this file can be used
     27 * under the LGPL license too
    2528 */
    2629#include <inttypes.h>

  • TabularUnified trunk/libswscale/rgb2rgb.h

    r261 r269  
    1010 * This file is part of FFmpeg.
    1111 *
    12  * FFmpeg is free software; you can redistribute it and/or modify
    13  * it under the terms of the GNU General Public License as published by
    14  * the Free Software Foundation; either version 2 of the License, or
    15  * (at your option) any later version.
     12 * FFmpeg is free software; you can redistribute it and/or
     13 * modify it under the terms of the GNU Lesser General Public
     14 * License as published by the Free Software Foundation; either
     15 * version 2.1 of the License, or (at your option) any later version.
    1616 *
    1717 * FFmpeg is distributed in the hope that it will be useful,
    1818 * but WITHOUT ANY WARRANTY; without even the implied warranty of
    19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    20  * GNU General Public License for more details.
     19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     20 * Lesser General Public License for more details.
    2121 *
    22  * You should have received a copy of the GNU General Public License
    23  * along with FFmpeg; if not, write to the Free Software
     22 * You should have received a copy of the GNU Lesser General Public
     23 * License along with FFmpeg; if not, write to the Free Software
    2424 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
    2525 */

  • TabularUnified trunk/libswscale/rgb2rgb_template.c

    r262 r269  
    2424 * along with FFmpeg; if not, write to the Free Software
    2525 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
     26 *
     27 * the C code (not assembly, mmx, ...) of this file can be used
     28 * under the LGPL license too
    2629 */
    2730

  • TabularUnified trunk/libswscale/swscale.c

    r261 r269  
    1818 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
    1919 *
    20  * the C code (not assembly, mmx, ...) of the swscaler which has been written
    21  * by Michael Niedermayer can be used under the LGPL license too
     20 * the C code (not assembly, mmx, ...) of this file can be used
     21 * under the LGPL license too
    2222 */
    2323
    … …  
    22982298#endif
    22992299                if(flags&SWS_FAST_BILINEAR)
    2300                         MSG_INFO("\nSwScaler: FAST_BILINEAR scaler, ");
     2300                        MSG_INFO("SwScaler: FAST_BILINEAR scaler, ");
    23012301                else if(flags&SWS_BILINEAR)
    2302                         MSG_INFO("\nSwScaler: BILINEAR scaler, ");
     2302                        MSG_INFO("SwScaler: BILINEAR scaler, ");
    23032303                else if(flags&SWS_BICUBIC)
    2304                         MSG_INFO("\nSwScaler: BICUBIC scaler, ");
     2304                        MSG_INFO("SwScaler: BICUBIC scaler, ");
    23052305                else if(flags&SWS_X)
    2306                         MSG_INFO("\nSwScaler: Experimental scaler, ");
     2306                        MSG_INFO("SwScaler: Experimental scaler, ");
    23072307                else if(flags&SWS_POINT)
    2308                         MSG_INFO("\nSwScaler: Nearest Neighbor / POINT scaler, ");
     2308                        MSG_INFO("SwScaler: Nearest Neighbor / POINT scaler, ");
    23092309                else if(flags&SWS_AREA)
    2310                         MSG_INFO("\nSwScaler: Area Averageing scaler, ");
     2310                        MSG_INFO("SwScaler: Area Averageing scaler, ");
    23112311                else if(flags&SWS_BICUBLIN)
    2312                         MSG_INFO("\nSwScaler: luma BICUBIC / chroma BILINEAR scaler, ");
     2312                        MSG_INFO("SwScaler: luma BICUBIC / chroma BILINEAR scaler, ");
    23132313                else if(flags&SWS_GAUSS)
    2314                         MSG_INFO("\nSwScaler: Gaussian scaler, ");
     2314                        MSG_INFO("SwScaler: Gaussian scaler, ");
    23152315                else if(flags&SWS_SINC)
    2316                         MSG_INFO("\nSwScaler: Sinc scaler, ");
     2316                        MSG_INFO("SwScaler: Sinc scaler, ");
    23172317                else if(flags&SWS_LANCZOS)
    2318                         MSG_INFO("\nSwScaler: Lanczos scaler, ");
     2318                        MSG_INFO("SwScaler: Lanczos scaler, ");
    23192319                else if(flags&SWS_SPLINE)
    2320                         MSG_INFO("\nSwScaler: Bicubic spline scaler, ");
     2320                        MSG_INFO("SwScaler: Bicubic spline scaler, ");
    23212321                else
    2322                         MSG_INFO("\nSwScaler: ehh flags invalid?! ");
     2322                        MSG_INFO("SwScaler: ehh flags invalid?! ");
    23232323
    23242324                if(dstFormat==PIX_FMT_BGR555 || dstFormat==PIX_FMT_BGR565)

  • TabularUnified trunk/libswscale/swscale.h

    r261 r269  
    44 * This file is part of FFmpeg.
    55 *
    6  * FFmpeg is free software; you can redistribute it and/or modify
    7  * it under the terms of the GNU General Public License as published by
    8  * the Free Software Foundation; either version 2 of the License, or
    9  * (at your option) any later version.
     6 * FFmpeg is free software; you can redistribute it and/or
     7 * modify it under the terms of the GNU Lesser General Public
     8 * License as published by the Free Software Foundation; either
     9 * version 2.1 of the License, or (at your option) any later version.
    1010 *
    1111 * FFmpeg is distributed in the hope that it will be useful,
    1212 * but WITHOUT ANY WARRANTY; without even the implied warranty of
    13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    14  * GNU General Public License for more details.
     13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     14 * Lesser General Public License for more details.
    1515 *
    16  * You should have received a copy of the GNU General Public License
    17  * along with FFmpeg; if not, write to the Free Software
     16 * You should have received a copy of the GNU Lesser General Public
     17 * License along with FFmpeg; if not, write to the Free Software
    1818 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
    19  *
    20  * the C code (not assembly, mmx, ...) of the swscaler which has been written
    21  * by Michael Niedermayer can be used under the LGPL license too
    2219 */
    2320

  • TabularUnified trunk/libswscale/swscale_internal.h

    r261 r269  
    44 * This file is part of FFmpeg.
    55 *
    6  * FFmpeg is free software; you can redistribute it and/or modify
    7  * it under the terms of the GNU General Public License as published by
    8  * the Free Software Foundation; either version 2 of the License, or
    9  * (at your option) any later version.
     6 * FFmpeg is free software; you can redistribute it and/or
     7 * modify it under the terms of the GNU Lesser General Public
     8 * License as published by the Free Software Foundation; either
     9 * version 2.1 of the License, or (at your option) any later version.
    1010 *
    1111 * FFmpeg is distributed in the hope that it will be useful,
    1212 * but WITHOUT ANY WARRANTY; without even the implied warranty of
    13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    14  * GNU General Public License for more details.
    15  *
    16  * You should have received a copy of the GNU General Public License
    17  * along with FFmpeg; if not, write to the Free Software
     13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     14 * Lesser General Public License for more details.
     15 *
     16 * You should have received a copy of the GNU Lesser General Public
     17 * License along with FFmpeg; if not, write to the Free Software
    1818 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
    19  *
    20  * the C code (not assembly, mmx, ...) of the swscaler which has been written
    21  * by Michael Niedermayer can be used under the LGPL license too
    2219 */
    2320

  • TabularUnified trunk/libswscale/swscale_template.c

    r262 r269  
    1818 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
    1919 *
    20  * the C code (not assembly, mmx, ...) of the swscaler which has been written
    21  * by Michael Niedermayer can be used under the LGPL license too
     20 * the C code (not assembly, mmx, ...) of this file can be used
     21 * under the LGPL license too
    2222 */
    2323
    … …  
    103103                        "jb 1b                          \n\t"\
    104104                        :: "r" (&c->redDither),\
    105                         "r" (dest), "p" (width)\
     105                        "r" (dest), "g" (width)\
    106106                        : "%"REG_a, "%"REG_d, "%"REG_S\
    107107                );
    … …  
    165165                        "jb 1b                          \n\t"\
    166166                        :: "r" (&c->redDither),\
    167                         "r" (dest), "p" (width)\
     167                        "r" (dest), "g" (width)\
    168168                        : "%"REG_a, "%"REG_d, "%"REG_S\
    169169                );
    … …  
    17311731static inline void RENAME(yuy2ToUV)(uint8_t *dstU, uint8_t *dstV, uint8_t *src1, uint8_t *src2, long width)
    17321732{
    1733 #if defined (HAVE_MMX2) || defined (HAVE_3DNOW)
     1733        assert(src1 == src2);
     1734#ifdef HAVE_MMX
    17341735        asm volatile(
    17351736                "movq "MANGLE(bm01010101)", %%mm4\n\t"
    … …  
    17381739                "movq (%1, %%"REG_a",4), %%mm0  \n\t"
    17391740                "movq 8(%1, %%"REG_a",4), %%mm1 \n\t"
    1740                 "movq (%2, %%"REG_a",4), %%mm2  \n\t"
    1741                 "movq 8(%2, %%"REG_a",4), %%mm3 \n\t"
    1742                 PAVGB(%%mm2, %%mm0)
    1743                 PAVGB(%%mm3, %%mm1)
    17441741                "psrlw $8, %%mm0                \n\t"
    17451742                "psrlw $8, %%mm1                \n\t"
    … …  
    17501747                "packuswb %%mm0, %%mm0          \n\t"
    17511748                "packuswb %%mm1, %%mm1          \n\t"
    1752                 "movd %%mm0, (%4, %%"REG_a")    \n\t"
    1753                 "movd %%mm1, (%3, %%"REG_a")    \n\t"
     1749                "movd %%mm0, (%3, %%"REG_a")    \n\t"
     1750                "movd %%mm1, (%2, %%"REG_a")    \n\t"
    17541751                "add $4, %%"REG_a"              \n\t"
    17551752                " js 1b                         \n\t"
    1756                 : : "g" (-width), "r" (src1+width*4), "r" (src2+width*4), "r" (dstU+width), "r" (dstV+width)
     1753                : : "g" (-width), "r" (src1+width*4), "r" (dstU+width), "r" (dstV+width)
    17571754                : "%"REG_a
    17581755        );
    … …  
    17611758        for(i=0; i<width; i++)
    17621759        {
    1763                 dstU[i]= (src1[4*i + 1] + src2[4*i + 1])>>1;
    1764                 dstV[i]= (src1[4*i + 3] + src2[4*i + 3])>>1;
     1760                dstU[i]= src1[4*i + 1];
     1761                dstV[i]= src1[4*i + 3];
    17651762        }
    17661763#endif
    … …  
    17941791static inline void RENAME(uyvyToUV)(uint8_t *dstU, uint8_t *dstV, uint8_t *src1, uint8_t *src2, long width)
    17951792{
    1796 #if defined (HAVE_MMX2) || defined (HAVE_3DNOW)
     1793        assert(src1 == src2);
     1794#ifdef HAVE_MMX
    17971795        asm volatile(
    17981796                "movq "MANGLE(bm01010101)", %%mm4\n\t"
    … …  
    18011799                "movq (%1, %%"REG_a",4), %%mm0  \n\t"
    18021800                "movq 8(%1, %%"REG_a",4), %%mm1 \n\t"
    1803                 "movq (%2, %%"REG_a",4), %%mm2  \n\t"
    1804                 "movq 8(%2, %%"REG_a",4), %%mm3 \n\t"
    1805                 PAVGB(%%mm2, %%mm0)
    1806                 PAVGB(%%mm3, %%mm1)
    18071801                "pand %%mm4, %%mm0              \n\t"
    18081802                "pand %%mm4, %%mm1              \n\t"
    … …  
    18131807                "packuswb %%mm0, %%mm0          \n\t"
    18141808                "packuswb %%mm1, %%mm1          \n\t"
    1815                 "movd %%mm0, (%4, %%"REG_a")    \n\t"
    1816                 "movd %%mm1, (%3, %%"REG_a")    \n\t"
     1809                "movd %%mm0, (%3, %%"REG_a")    \n\t"
     1810                "movd %%mm1, (%2, %%"REG_a")    \n\t"
    18171811                "add $4, %%"REG_a"              \n\t"
    18181812                " js 1b                         \n\t"
    1819                 : : "g" (-width), "r" (src1+width*4), "r" (src2+width*4), "r" (dstU+width), "r" (dstV+width)
     1813                : : "g" (-width), "r" (src1+width*4), "r" (dstU+width), "r" (dstV+width)
    18201814                : "%"REG_a
    18211815        );
    … …  
    18241818        for(i=0; i<width; i++)
    18251819        {
    1826                 dstU[i]= (src1[4*i + 0] + src2[4*i + 0])>>1;
    1827                 dstV[i]= (src1[4*i + 2] + src2[4*i + 2])>>1;
     1820                dstU[i]= src1[4*i + 0];
     1821                dstV[i]= src1[4*i + 2];
    18281822        }
    18291823#endif
    … …  
    18461840{
    18471841        int i;
     1842        assert(src1 == src2);
    18481843        for(i=0; i<width; i++)
    18491844        {
    18501845                const int a= ((uint32_t*)src1)[2*i+0];
    18511846                const int e= ((uint32_t*)src1)[2*i+1];
    1852                 const int c= ((uint32_t*)src2)[2*i+0];
    1853                 const int d= ((uint32_t*)src2)[2*i+1];
    1854                 const int l= (a&0xFF00FF) + (e&0xFF00FF) + (c&0xFF00FF) + (d&0xFF00FF);
    1855                 const int h= (a&0x00FF00) + (e&0x00FF00) + (c&0x00FF00) + (d&0x00FF00);
     1847                const int l= (a&0xFF00FF) + (e&0xFF00FF);
     1848                const int h= (a&0x00FF00) + (e&0x00FF00);
    18561849                const int b=  l&0x3FF;
    18571850                const int g=  h>>8;
    18581851                const int r=  l>>16;
    18591852
    1860                 dstU[i]= ((RU*r + GU*g + BU*b)>>(RGB2YUV_SHIFT+2)) + 128;
    1861                 dstV[i]= ((RV*r + GV*g + BV*b)>>(RGB2YUV_SHIFT+2)) + 128;
     1853                dstU[i]= ((RU*r + GU*g + BU*b)>>(RGB2YUV_SHIFT+1)) + 128;
     1854                dstV[i]= ((RV*r + GV*g + BV*b)>>(RGB2YUV_SHIFT+1)) + 128;
    18621855        }
    18631856}
    … …  
    19501943static inline void RENAME(bgr24ToUV)(uint8_t *dstU, uint8_t *dstV, uint8_t *src1, uint8_t *src2, long width)
    19511944{
     1945        assert(src1 == src2);
    19521946#ifdef HAVE_MMX
    19531947        asm volatile(
    1954                 "mov %4, %%"REG_a"              \n\t"
     1948                "mov %3, %%"REG_a"              \n\t"
    19551949                "movq "MANGLE(w1111)", %%mm5            \n\t"
    19561950                "movq "MANGLE(bgr2UCoeff)", %%mm6               \n\t"
    … …  
    19611955                "1:                             \n\t"
    19621956                PREFETCH" 64(%0, %%"REG_d")     \n\t"
    1963                 PREFETCH" 64(%1, %%"REG_d")     \n\t"
    19641957#if defined (HAVE_MMX2) || defined (HAVE_3DNOW)
    19651958                "movq (%0, %%"REG_d"), %%mm0    \n\t"
    1966                 "movq (%1, %%"REG_d"), %%mm1    \n\t"
    19671959                "movq 6(%0, %%"REG_d"), %%mm2   \n\t"
    1968                 "movq 6(%1, %%"REG_d"), %%mm3   \n\t"
    1969                 PAVGB(%%mm1, %%mm0)
    1970                 PAVGB(%%mm3, %%mm2)
    19711960                "movq %%mm0, %%mm1              \n\t"
    19721961                "movq %%mm2, %%mm3              \n\t"
    … …  
    19791968#else
    19801969                "movd (%0, %%"REG_d"), %%mm0    \n\t"
    1981                 "movd (%1, %%"REG_d"), %%mm1    \n\t"
    19821970                "movd 3(%0, %%"REG_d"), %%mm2   \n\t"
    1983                 "movd 3(%1, %%"REG_d"), %%mm3   \n\t"
    19841971                "punpcklbw %%mm7, %%mm0         \n\t"
    1985                 "punpcklbw %%mm7, %%mm1         \n\t"
    19861972                "punpcklbw %%mm7, %%mm2         \n\t"
    1987                 "punpcklbw %%mm7, %%mm3         \n\t"
    1988                 "paddw %%mm1, %%mm0             \n\t"
    1989                 "paddw %%mm3, %%mm2             \n\t"
    19901973                "paddw %%mm2, %%mm0             \n\t"
    19911974                "movd 6(%0, %%"REG_d"), %%mm4   \n\t"
    1992                 "movd 6(%1, %%"REG_d"), %%mm1   \n\t"
    19931975                "movd 9(%0, %%"REG_d"), %%mm2   \n\t"
    1994                 "movd 9(%1, %%"REG_d"), %%mm3   \n\t"
    19951976                "punpcklbw %%mm7, %%mm4         \n\t"
    1996                 "punpcklbw %%mm7, %%mm1         \n\t"
    19971977                "punpcklbw %%mm7, %%mm2         \n\t"
    1998                 "punpcklbw %%mm7, %%mm3         \n\t"
    1999                 "paddw %%mm1, %%mm4             \n\t"
    2000                 "paddw %%mm3, %%mm2             \n\t"
    20011978                "paddw %%mm4, %%mm2             \n\t"
    2002                 "psrlw $2, %%mm0                \n\t"
    2003                 "psrlw $2, %%mm2                \n\t"
     1979                "psrlw $1, %%mm0                \n\t"
     1980                "psrlw $1, %%mm2                \n\t"
    20041981#endif
    20051982                "movq "MANGLE(bgr2VCoeff)", %%mm1               \n\t"
    … …  
    20252002#if defined (HAVE_MMX2) || defined (HAVE_3DNOW)
    20262003                "movq 12(%0, %%"REG_d"), %%mm4  \n\t"
    2027                 "movq 12(%1, %%"REG_d"), %%mm1  \n\t"
    20282004                "movq 18(%0, %%"REG_d"), %%mm2  \n\t"
    2029                 "movq 18(%1, %%"REG_d"), %%mm3  \n\t"
    2030                 PAVGB(%%mm1, %%mm4)
    2031                 PAVGB(%%mm3, %%mm2)
    20322005                "movq %%mm4, %%mm1              \n\t"
    20332006                "movq %%mm2, %%mm3              \n\t"
    … …  
    20402013#else
    20412014                "movd 12(%0, %%"REG_d"), %%mm4  \n\t"
    2042                 "movd 12(%1, %%"REG_d"), %%mm1  \n\t"
    20432015                "movd 15(%0, %%"REG_d"), %%mm2  \n\t"
    2044                 "movd 15(%1, %%"REG_d"), %%mm3  \n\t"
    20452016                "punpcklbw %%mm7, %%mm4         \n\t"
    2046                 "punpcklbw %%mm7, %%mm1         \n\t"
    20472017                "punpcklbw %%mm7, %%mm2         \n\t"
    2048                 "punpcklbw %%mm7, %%mm3         \n\t"
    2049                 "paddw %%mm1, %%mm4             \n\t"
    2050                 "paddw %%mm3, %%mm2             \n\t"
    20512018                "paddw %%mm2, %%mm4             \n\t"
    20522019                "movd 18(%0, %%"REG_d"), %%mm5  \n\t"
    2053                 "movd 18(%1, %%"REG_d"), %%mm1  \n\t"
    20542020                "movd 21(%0, %%"REG_d"), %%mm2  \n\t"
    2055                 "movd 21(%1, %%"REG_d"), %%mm3  \n\t"
    20562021                "punpcklbw %%mm7, %%mm5         \n\t"
    2057                 "punpcklbw %%mm7, %%mm1         \n\t"
    20582022                "punpcklbw %%mm7, %%mm2         \n\t"
    2059                 "punpcklbw %%mm7, %%mm3         \n\t"
    2060                 "paddw %%mm1, %%mm5             \n\t"
    2061                 "paddw %%mm3, %%mm2             \n\t"
    20622023                "paddw %%mm5, %%mm2             \n\t"
    20632024                "movq "MANGLE(w1111)", %%mm5            \n\t"
    … …  
    20922053                "paddb "MANGLE(bgr2UVOffset)", %%mm0    \n\t"
    20932054
     2055                "movd %%mm0, (%1, %%"REG_a")    \n\t"
     2056                "punpckhdq %%mm0, %%mm0         \n\t"
    20942057                "movd %%mm0, (%2, %%"REG_a")    \n\t"
    2095                 "punpckhdq %%mm0, %%mm0         \n\t"
    2096                 "movd %%mm0, (%3, %%"REG_a")    \n\t"
    20972058                "add $4, %%"REG_a"              \n\t"
    20982059                " js 1b                         \n\t"
    2099                 : : "r" (src1+width*6), "r" (src2+width*6), "r" (dstU+width), "r" (dstV+width), "g" (-width)
     2060                : : "r" (src1+width*6), "r" (dstU+width), "r" (dstV+width), "g" (-width)
    21002061                : "%"REG_a, "%"REG_d
    21012062        );
    … …  
    21042065        for(i=0; i<width; i++)
    21052066        {
    2106                 int b= src1[6*i + 0] + src1[6*i + 3] + src2[6*i + 0] + src2[6*i + 3];
    2107                 int g= src1[6*i + 1] + src1[6*i + 4] + src2[6*i + 1] + src2[6*i + 4];
    2108                 int r= src1[6*i + 2] + src1[6*i + 5] + src2[6*i + 2] + src2[6*i + 5];
    2109 
    2110                 dstU[i]= ((RU*r + GU*g + BU*b)>>(RGB2YUV_SHIFT+2)) + 128;
    2111                 dstV[i]= ((RV*r + GV*g + BV*b)>>(RGB2YUV_SHIFT+2)) + 128;
     2067                int b= src1[6*i + 0] + src1[6*i + 3];
     2068                int g= src1[6*i + 1] + src1[6*i + 4];
     2069                int r= src1[6*i + 2] + src1[6*i + 5];
     2070
     2071                dstU[i]= ((RU*r + GU*g + BU*b)>>(RGB2YUV_SHIFT+1)) + 128;
     2072                dstV[i]= ((RV*r + GV*g + BV*b)>>(RGB2YUV_SHIFT+1)) + 128;
    21122073        }
    21132074#endif
    … …  
    21312092{
    21322093        int i;
     2094        assert(src1==src2);
    21332095        for(i=0; i<width; i++)
    21342096        {
    21352097                int d0= ((uint32_t*)src1)[i];
    2136                 int d1= ((uint32_t*)src2)[i];
    21372098               
    2138                 int dl= (d0&0x07E0F81F) + (d1&0x07E0F81F);
    2139                 int dh= ((d0>>5)&0x07C0F83F) + ((d1>>5)&0x07C0F83F);
     2099                int dl= (d0&0x07E0F81F);
     2100                int dh= ((d0>>5)&0x07C0F83F);
    21402101
    21412102                int dh2= (dh>>11) + (dh<<21);
    … …  
    21452106                int r= (d>>11)&0x7F;
    21462107                int g= d>>21;
    2147                 dstU[i]= ((2*RU*r + GU*g + 2*BU*b)>>(RGB2YUV_SHIFT+2-2)) + 128;
    2148                 dstV[i]= ((2*RV*r + GV*g + 2*BV*b)>>(RGB2YUV_SHIFT+2-2)) + 128;
     2108                dstU[i]= ((2*RU*r + GU*g + 2*BU*b)>>(RGB2YUV_SHIFT+1-2)) + 128;
     2109                dstV[i]= ((2*RV*r + GV*g + 2*BV*b)>>(RGB2YUV_SHIFT+1-2)) + 128;
    21492110        }
    21502111}
    … …  
    21672128{
    21682129        int i;
     2130        assert(src1==src2);
    21692131        for(i=0; i<width; i++)
    21702132        {
    21712133                int d0= ((uint32_t*)src1)[i];
    2172                 int d1= ((uint32_t*)src2)[i];
    21732134               
    2174                 int dl= (d0&0x03E07C1F) + (d1&0x03E07C1F);
    2175                 int dh= ((d0>>5)&0x03E0F81F) + ((d1>>5)&0x03E0F81F);
     2135                int dl= (d0&0x03E07C1F);
     2136                int dh= ((d0>>5)&0x03E0F81F);
    21762137
    21772138                int dh2= (dh>>11) + (dh<<21);
    … …  
    21812142                int r= (d>>10)&0x7F;
    21822143                int g= d>>21;
    2183                 dstU[i]= ((RU*r + GU*g + BU*b)>>(RGB2YUV_SHIFT+2-3)) + 128;
    2184                 dstV[i]= ((RV*r + GV*g + BV*b)>>(RGB2YUV_SHIFT+2-3)) + 128;
     2144                dstU[i]= ((RU*r + GU*g + BU*b)>>(RGB2YUV_SHIFT+1-3)) + 128;
     2145                dstV[i]= ((RV*r + GV*g + BV*b)>>(RGB2YUV_SHIFT+1-3)) + 128;
    21852146        }
    21862147}
    … …  
    22032164{
    22042165        int i;
     2166        assert(src1==src2);
    22052167        for(i=0; i<width; i++)
    22062168        {
    22072169                const int a= ((uint32_t*)src1)[2*i+0];
    22082170                const int e= ((uint32_t*)src1)[2*i+1];
    2209                 const int c= ((uint32_t*)src2)[2*i+0];
    2210                 const int d= ((uint32_t*)src2)[2*i+1];
    2211                 const int l= (a&0xFF00FF) + (e&0xFF00FF) + (c&0xFF00FF) + (d&0xFF00FF);
    2212                 const int h= (a&0x00FF00) + (e&0x00FF00) + (c&0x00FF00) + (d&0x00FF00);
     2171                const int l= (a&0xFF00FF) + (e&0xFF00FF);
     2172                const int h= (a&0x00FF00) + (e&0x00FF00);
    22132173                const int r=  l&0x3FF;
    22142174                const int g=  h>>8;
    22152175                const int b=  l>>16;
    22162176
    2217                 dstU[i]= ((RU*r + GU*g + BU*b)>>(RGB2YUV_SHIFT+2)) + 128;
    2218                 dstV[i]= ((RV*r + GV*g + BV*b)>>(RGB2YUV_SHIFT+2)) + 128;
     2177                dstU[i]= ((RU*r + GU*g + BU*b)>>(RGB2YUV_SHIFT+1)) + 128;
     2178                dstV[i]= ((RV*r + GV*g + BV*b)>>(RGB2YUV_SHIFT+1)) + 128;
    22192179        }
    22202180}
    … …  
    22362196{
    22372197        int i;
     2198        assert(src1==src2);
    22382199        for(i=0; i<width; i++)
    22392200        {
    2240                 int r= src1[6*i + 0] + src1[6*i + 3] + src2[6*i + 0] + src2[6*i + 3];
    2241                 int g= src1[6*i + 1] + src1[6*i + 4] + src2[6*i + 1] + src2[6*i + 4];
    2242                 int b= src1[6*i + 2] + src1[6*i + 5] + src2[6*i + 2] + src2[6*i + 5];
    2243 
    2244                 dstU[i]= ((RU*r + GU*g + BU*b)>>(RGB2YUV_SHIFT+2)) + 128;
    2245                 dstV[i]= ((RV*r + GV*g + BV*b)>>(RGB2YUV_SHIFT+2)) + 128;
     2201                int r= src1[6*i + 0] + src1[6*i + 3];
     2202                int g= src1[6*i + 1] + src1[6*i + 4];
     2203                int b= src1[6*i + 2] + src1[6*i + 5];
     2204
     2205                dstU[i]= ((RU*r + GU*g + BU*b)>>(RGB2YUV_SHIFT+1)) + 128;
     2206                dstV[i]= ((RV*r + GV*g + BV*b)>>(RGB2YUV_SHIFT+1)) + 128;
    22462207        }
    22472208}
    … …  
    22642225{
    22652226        int i;
     2227        assert(src1 == src2);
    22662228        for(i=0; i<width; i++)
    22672229        {
    22682230                int d0= ((uint32_t*)src1)[i];
    2269                 int d1= ((uint32_t*)src2)[i];
    22702231               
    2271                 int dl= (d0&0x07E0F81F) + (d1&0x07E0F81F);
    2272                 int dh= ((d0>>5)&0x07C0F83F) + ((d1>>5)&0x07C0F83F);
     2232                int dl= (d0&0x07E0F81F);
     2233                int dh= ((d0>>5)&0x07C0F83F);
    22732234
    22742235                int dh2= (dh>>11) + (dh<<21);
    … …  
    22782239                int b= (d>>11)&0x7F;
    22792240                int g= d>>21;
    2280                 dstU[i]= ((2*RU*r + GU*g + 2*BU*b)>>(RGB2YUV_SHIFT+2-2)) + 128;
    2281                 dstV[i]= ((2*RV*r + GV*g + 2*BV*b)>>(RGB2YUV_SHIFT+2-2)) + 128;
     2241                dstU[i]= ((2*RU*r + GU*g + 2*BU*b)>>(RGB2YUV_SHIFT+1-2)) + 128;
     2242                dstV[i]= ((2*RV*r + GV*g + 2*BV*b)>>(RGB2YUV_SHIFT+1-2)) + 128;
    22822243        }
    22832244}
    … …  
    23002261{
    23012262        int i;
     2263        assert(src1 == src2);
    23022264        for(i=0; i<width; i++)
    23032265        {
    23042266                int d0= ((uint32_t*)src1)[i];
    2305                 int d1= ((uint32_t*)src2)[i];
    23062267               
    2307                 int dl= (d0&0x03E07C1F) + (d1&0x03E07C1F);
    2308                 int dh= ((d0>>5)&0x03E0F81F) + ((d1>>5)&0x03E0F81F);
     2268                int dl= (d0&0x03E07C1F);
     2269                int dh= ((d0>>5)&0x03E0F81F);
    23092270
    23102271                int dh2= (dh>>11) + (dh<<21);
    … …  
    23142275                int r= (d>>10)&0x7F;
    23152276                int b= d>>21;
    2316                 dstU[i]= ((RU*r + GU*g + BU*b)>>(RGB2YUV_SHIFT+2-3)) + 128;
    2317                 dstV[i]= ((RV*r + GV*g + BV*b)>>(RGB2YUV_SHIFT+2-3)) + 128;
     2277                dstU[i]= ((RU*r + GU*g + BU*b)>>(RGB2YUV_SHIFT+1-3)) + 128;
     2278                dstV[i]= ((RV*r + GV*g + BV*b)>>(RGB2YUV_SHIFT+1-3)) + 128;
    23182279        }
    23192280}

  • TabularUnified trunk/makefile

    r265 r269  
    11!include Makefile.inc
     2OBJ_LIB = objlib.lib
    23
    34OBJS = audio\adecode.obj \
    … …  
    1617        g++ $(INCL) $(CFLAGS) $(DFLAGS) $(OFLAGS) -o $@ -c $<
    1718
    18 all: $(OBJS)
     19all: $(OBJ_LIB)
     20
     21$(OBJ_LIB): $(OBJS)
     22        -del $(OBJ_LIB)
     23        emxomfar r $@ $(OBJS)
    1924
    2025clean:

  • TabularUnified trunk/stream/realrtsp/real.c

    r265 r269  
    3232
    3333#include "../config.h"
    34 #include "../bswap.h"
     34#include "libavutil/common.h"
     35#include "libavutil/bswap.h"
    3536#include "real.h"
    3637#include "asmrp.h"

  • TabularUnified trunk/stream/stream_cdda.c

    r265 r269  
    11#include "config.h"
     2
     3#include <stdio.h>
     4#include <stdlib.h>
    25
    36#include "stream.h"
    47#include "m_option.h"
    58#include "m_struct.h"
    6 #include "bswap.h"
    7 
    8 #include <stdio.h>
    9 #include <stdlib.h>
     9#include "libavutil/common.h"
     10#include "libavutil/bswap.h"
     11
    1012#include "libmpdemux/demuxer.h"
    1113

  • TabularUnified trunk/stream/stream_dvdnav.c

    r268 r269  
    464464}
    465465
     466/**
     467 * \brief dvdnav_sid_from_lang() returns the subtitle id corresponding to the language code 'lang'
     468 * \param stream: - stream pointer
     469 * \param lang: 2-characters language code[s], eventually separated by spaces of commas
     470 * \return -1 on error, current subtitle id if successful
     471 */
    466472int dvdnav_sid_from_lang(stream_t *stream, unsigned char *language) {
    467473    dvdnav_priv_t * priv=(dvdnav_priv_t*)stream->priv;
    … …  
    485491}
    486492
     493/**
     494 * \brief dvdnav_number_of_subs() returns the count of available subtitles
     495 * \param stream: - stream pointer
     496 * \return 0 on error, something meaningful otherwise
     497 */
    487498int dvdnav_number_of_subs(stream_t *stream) {
    488499    dvdnav_priv_t * priv=(dvdnav_priv_t*)stream->priv;

  • TabularUnified trunk/stream/stream_netstream.c

    r265 r269  
    6161#include "m_option.h"
    6262#include "m_struct.h"
    63 #include "bswap.h"
     63#include "libavutil/common.h"
     64#include "libavutil/bswap.h"
    6465
    6566#include "netstream.h"

  • TabularUnified trunk/video/vdecode.c

    r266 r269  
    171171extern int showsubs;
    172172extern RECTL subRcl;
    173 extern spudec_handle_t *spudec;
     173extern void *spudec;
    174174
    175175#define UNPACK_RGB16(packed_pixel, r, g, b) \
    … …  
    774774    dive_internal_buffer = dive_buffer;
    775775    dive_internal_bpl = bpl;
    776 
    777     //    printf("vc\n");fflush(stdout);
    778     in_size = video_read_frame(sh_video, &frame_time, &start,force_fps);
     776    frame_time = sh_video->next_frame_time;
     777
     778    printf("vc\n");fflush(stdout);
     779    in_size = video_read_frame(sh_video, &/*frame_time*/sh_video->next_frame_time, &start,force_fps);
     780    printf("vc1\n");fflush(stdout);
    779781
    780782    if (in_size < 0)
    … …  
    837839            }
    838840#endif
    839 //            printf("cp 0, start: %X, size: %i\n",start, in_size);fflush(stdout);
     841            printf("cp 0, start: %X, size: %i\n",start, in_size);fflush(stdout);
    840842            //            avcodec_get_frame_defaults(&video_picture);
    841843            ret = avcodec_decode_video(video_context, &video_picture,
    … …  
    849851                fclose(ff);
    850852            }
    851 //#endif
     853#endif
    852854            printf("cp. %x, %x, %x. %i, %i\n",video_picture.data[0],
    853855                   video_picture.data[1],
    854856                   video_picture.data[2], ret, got_picture);fflush(stdout);
    855 #endif
     857//#endif
    856858            //            if (video_context->frame_rate)
    857859            //                printf("ffpts: %f\n",(AV_TIME_BASE * video_context->frame_rate_base) / video_context->frame_rate);
    … …  
    11061108    int Y,U,V;
    11071109
    1108     //    printf("sub: x0 = %i, y0 = %i, w= %i, h = %i\n",x0,y0,w,h);
     1110        printf("sub: x0 = %i, y0 = %i, w= %i, h = %i\n",x0,y0,w,h);
    11091111
    11101112    if (!src) return;
    … …  
    11461148    unsigned char *dst = OSDBuffer;
    11471149
    1148     //printf("x0 = %i, y0 = %i, w= %i, h = %i, subw: %i\n",x0,y0,w,h, subwidth);
     1150    printf("x0 = %i, y0 = %i, w= %i, h = %i, subw: %i\n",x0,y0,w,h, subwidth);
    11491151
    11501152    if (VOutCaps->ctrlCaps & VOUTCAPS_32BITALIGN)
    … …  
    14541456    //printf("called divecallback stride0 = %i, stride1 = %i\n",stride0, stride1);
    14551457
    1456     //printf("cp1, %x, %x\n", showsubs, OSDCommand);fflush(stdout);
     1458    printf("dive callback, %x, %x\n", showsubs, OSDCommand);fflush(stdout);
    14571459
    14581460    if ((showsubs || OSDCommand != OSDNONE) &&
    … …  
    14611463        subwidth = stride0;
    14621464        if (showsubs) // DVD subtitles
    1463             spudec_draw_scaled(spudec, width,
    1464                                height,
    1465                                draw_alpha_to_yuv);
     1465            spudec_draw_scaled(spudec, width, height, draw_alpha_to_yuv);
    14661466
    14671467       //         printf("vd. cp0\n");fflush(stdout);
    … …  
    15311531                    //printf("vd. w: %i, h: %i\n",
    15321532                    //       width, height);fflush(stdout);
    1533                     yv12toyuy2(suby, subu, subv,
     1533                    yv12toyuy2_my(suby, subu, subv,
    15341534                               (unsigned char *)dive_internal_buffer,
    15351535                               width, height,
    … …  
    15441544                        //printf("showsubs = %i\n", showsubs);
    15451545                        if (showsubs) // DVD subtitles
    1546                             spudec_draw_scaled(spudec, (width + 15) &~ 15,
    1547                                                height,
     1546                            spudec_draw/*_scaled*/(spudec,/* (width + 15) &~ 15,
     1547                                               height,*/
    15481548                                               draw_alpha_to_yuv2);
    15491549                        //printf("OSDCommand = %i\n", OSDCommand);

  • TabularUnified trunk/yuv/yuv2rgb.c

    r168 r269  
    6161uint32_t matrix_coefficients = 6;
    6262
    63 const int32_t Inverse_Table_6_9[8][4] = {
     63const int32_t Inverse_Table_6_9_1[8][4] = {
    6464    {117504, 138453, 13954, 34903}, /* no sequence_display_extension */
    6565    {117504, 138453, 13954, 34903}, /* ITU-R Rec. 709 (1990) */
    … …  
    496496    void *table_r = 0, *table_g = 0, *table_b = 0;
    497497
    498     int crv = Inverse_Table_6_9[matrix_coefficients][0];
    499     int cbu = Inverse_Table_6_9[matrix_coefficients][1];
    500     int cgu = -Inverse_Table_6_9[matrix_coefficients][2];
    501     int cgv = -Inverse_Table_6_9[matrix_coefficients][3];
     498    int crv = Inverse_Table_6_9_1[matrix_coefficients][0];
     499    int cbu = Inverse_Table_6_9_1[matrix_coefficients][1];
     500    int cgu = -Inverse_Table_6_9_1[matrix_coefficients][2];
     501    int cgv = -Inverse_Table_6_9_1[matrix_coefficients][3];
    502502
    503503    for (i = 0; i < 1024; i++)
    … …  
    669669}
    670670
    671 void yv12toyuy2(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc,
     671void yv12toyuy2_my(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc,
    672672                uint8_t *dst, unsigned int width, unsigned int height,
    673673                unsigned int lumStride, unsigned int chromStride,

  • TabularUnified trunk/yuv/yuv2rgb.h

    r64 r269  
    1919void yv12toyuy2_init(void);
    2020
    21 void yv12toyuy2(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc,
     21void yv12toyuy2_my(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc,
    2222                uint8_t *dst, unsigned int width, unsigned int height,
    2323                unsigned int lumStride, unsigned int chromStride,
Note: See TracChangeset for help on using the changeset viewer.