git.sesse.net Git - vlc/blob - modules/packetizer/mpeg4video.c

   1 /*****************************************************************************
   2  * mpeg4video.c
   3  *****************************************************************************
   4  * Copyright (C) 2001, 2002 VideoLAN
   5  * $Id: mpeg4video.c,v 1.7 2003/01/23 15:52:04 sam Exp $
   6  *
   7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   8  *          Eric Petit <titer@videolan.org>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28 #include <vlc/vlc.h>
  29 #include <vlc/aout.h>
  30 #include <vlc/decoder.h>
  31 #include <vlc/input.h>
  32 #include <vlc/sout.h>
  33
  34 #include <stdlib.h>                                      /* malloc(), free() */
  35 #include <string.h>                                              /* strdup() */
  36
  37 #include "codecs.h"
  38
  39 /*****************************************************************************
  40  * Local prototypes
  41  *****************************************************************************/
  42 typedef struct packetizer_thread_s
  43 {
  44     /* Input properties */
  45     decoder_fifo_t          *p_fifo;
  46
  47     /* Output properties */
  48     sout_input_t            *p_sout_input;
  49     sout_packet_format_t    output_format;
  50
  51     mtime_t i_pts_start;
  52
  53     int                     i_vol;
  54     uint8_t                 *p_vol;
  55
  56 } packetizer_thread_t;
  57
  58 static int  Open    ( vlc_object_t * );
  59 static int  Run     ( decoder_fifo_t * );
  60
  61 static int  InitThread     ( packetizer_thread_t * );
  62 static void PacketizeThread   ( packetizer_thread_t * );
  63 static void EndThread      ( packetizer_thread_t * );
  64
  65
  66 static void input_ShowPES( decoder_fifo_t *p_fifo, pes_packet_t **pp_pes );
  67
  68 /*****************************************************************************
  69  * Module descriptor
  70  *****************************************************************************/
  71
  72 vlc_module_begin();
  73     set_description( _("MPEG4 Video packetizer") );
  74     set_capability( "packetizer", 50 );
  75     set_callbacks( Open, NULL );
  76 vlc_module_end();
  77
  78 #define VIDEO_OBJECT_MASK                       0x01f
  79 #define VIDEO_OBJECT_LAYER_MASK                 0x00f
  80
  81 #define VIDEO_OBJECT_START_CODE                 0x100
  82 #define VIDEO_OBJECT_LAYER_START_CODE           0x120
  83 #define VISUAL_OBJECT_SEQUENCE_START_CODE       0x1b0
  84 #define VISUAL_OBJECT_SEQUENCE_END_CODE         0x1b1
  85 #define USER_DATA_START_CODE                    0x1b2
  86 #define GROUP_OF_VOP_START_CODE                 0x1b3
  87 #define VIDEO_SESSION_ERROR_CODE                0x1b4
  88 #define VISUAL_OBJECT_START_CODE                0x1b5
  89 #define VOP_START_CODE                          0x1b6
  90 #define FACE_OBJECT_START_CODE                  0x1ba
  91 #define FACE_OBJECT_PLANE_START_CODE            0x1bb
  92 #define MESH_OBJECT_START_CODE                  0x1bc
  93 #define MESH_OBJECT_PLANE_START_CODE            0x1bd
  94 #define STILL_TEXTURE_OBJECT_START_CODE         0x1be
  95 #define TEXTURE_SPATIAL_LAYER_START_CODE        0x1bf
  96 #define TEXTURE_SNR_LAYER_START_CODE            0x1c0
  97
  98
  99 /*****************************************************************************
 100  * OpenDecoder: probe the packetizer and return score
 101  *****************************************************************************
 102  * Tries to launch a decoder and return score so that the interface is able
 103  * to choose.
 104  *****************************************************************************/
 105 static int Open( vlc_object_t *p_this )
 106 {
 107     decoder_fifo_t *p_fifo = (decoder_fifo_t*) p_this;
 108
 109     p_fifo->pf_run = Run;
 110
 111     switch(  p_fifo->i_fourcc )
 112     {
 113         case VLC_FOURCC( 'm', '4', 's', '2'):
 114         case VLC_FOURCC( 'M', '4', 'S', '2'):
 115         case VLC_FOURCC( 'm', 'p', '4', 's'):
 116         case VLC_FOURCC( 'M', 'P', '4', 'S'):
 117         case VLC_FOURCC( 'm', 'p', '4', 'v'):
 118         case VLC_FOURCC( 'D', 'I', 'V', 'X'):
 119         case VLC_FOURCC( 'd', 'i', 'v', 'x'):
 120         case VLC_FOURCC( 'X', 'V', 'I', 'D'):
 121         case VLC_FOURCC( 'X', 'v', 'i', 'D'):
 122         case VLC_FOURCC( 'x', 'v', 'i', 'd'):
 123         case VLC_FOURCC( 'D', 'X', '5', '0'):
 124         case VLC_FOURCC( 0x04, 0,   0,   0):
 125         case VLC_FOURCC( '3', 'I', 'V', '2'):
 126
 127             return VLC_SUCCESS;
 128         default:
 129             return VLC_EGENERIC;
 130     }
 131 }
 132
 133 /*****************************************************************************
 134  * RunDecoder: this function is called just after the thread is created
 135  *****************************************************************************/
 136 static int Run( decoder_fifo_t *p_fifo )
 137 {
 138     packetizer_thread_t *p_pack;
 139     int b_error;
 140
 141     msg_Info( p_fifo, "Running MPEG4 Video packetizer" );
 142     if( !( p_pack = malloc( sizeof( packetizer_thread_t ) ) ) )
 143     {
 144         msg_Err( p_fifo, "out of memory" );
 145         DecoderError( p_fifo );
 146         return( -1 );
 147     }
 148     memset( p_pack, 0, sizeof( packetizer_thread_t ) );
 149
 150     p_pack->p_fifo = p_fifo;
 151
 152     if( InitThread( p_pack ) != 0 )
 153     {
 154         DecoderError( p_fifo );
 155         return( -1 );
 156     }
 157
 158     while( ( !p_pack->p_fifo->b_die )&&( !p_pack->p_fifo->b_error ) )
 159     {
 160         PacketizeThread( p_pack );
 161     }
 162
 163
 164     if( ( b_error = p_pack->p_fifo->b_error ) )
 165     {
 166         DecoderError( p_pack->p_fifo );
 167     }
 168
 169     EndThread( p_pack );
 170     if( b_error )
 171     {
 172         return( -1 );
 173     }
 174
 175     return( 0 );
 176 }
 177
 178
 179 #define FREE( p ) if( p ) free( p ); p = NULL
 180
 181 /*****************************************************************************
 182  * InitThread: initialize data before entering main loop
 183  *****************************************************************************/
 184
 185 static int InitThread( packetizer_thread_t *p_pack )
 186 {
 187     BITMAPINFOHEADER *p_bih;
 188
 189     p_bih = (BITMAPINFOHEADER*)p_pack->p_fifo->p_bitmapinfoheader;
 190
 191     if( p_bih && p_bih->biSize > sizeof( BITMAPINFOHEADER ) )
 192     {
 193         /* We have a vol */
 194         p_pack->i_vol = p_bih->biSize - sizeof( BITMAPINFOHEADER );
 195         p_pack->p_vol = malloc( p_pack->i_vol );
 196         memcpy( p_pack->p_vol, &p_bih[1], p_pack->i_vol );
 197
 198         /* create stream input output */
 199         p_pack->output_format.i_cat = VIDEO_ES;
 200         p_pack->output_format.i_fourcc = VLC_FOURCC( 'm', 'p', '4', 'v' );
 201         p_pack->output_format.p_format = malloc( p_bih->biSize );
 202         memcpy( p_pack->output_format.p_format, p_bih, p_bih->biSize );
 203
 204         msg_Warn( p_pack->p_fifo, "opening with vol size:%d", p_pack->i_vol );
 205         p_pack->p_sout_input =
 206             sout_InputNew( p_pack->p_fifo,
 207                            &p_pack->output_format );
 208     }
 209     else
 210     {
 211         p_pack->i_vol = 0;
 212         p_pack->p_vol = 0;
 213         p_pack->output_format.i_cat = UNKNOWN_ES;
 214         p_pack->output_format.i_fourcc = VLC_FOURCC( 'n', 'u', 'l', 'l' );
 215         p_pack->output_format.p_format = NULL;
 216
 217         p_pack->p_sout_input =
 218             sout_InputNew( p_pack->p_fifo,
 219                            &p_pack->output_format );
 220     }
 221
 222     if( !p_pack->p_sout_input )
 223     {
 224         msg_Err( p_pack->p_fifo, "cannot add a new stream" );
 225         return( -1 );
 226     }
 227     p_pack->i_pts_start = -1;
 228     return( 0 );
 229 }
 230
 231 static int m4v_FindStartCode( uint8_t **pp_data, uint8_t *p_end )
 232 {
 233     for( ; *pp_data < p_end - 4; (*pp_data)++ )
 234     {
 235         if( (*pp_data)[0] == 0 && (*pp_data)[1] == 0 && (*pp_data)[2] == 1 )
 236         {
 237             return( 0 );
 238         }
 239     }
 240     fprintf( stderr, "\n********* cannot find startcode\n" );
 241     return( -1 );
 242 }
 243 /*****************************************************************************
 244  * PacketizeThread: packetize an unit (here copy a complete pes)
 245  *****************************************************************************/
 246 static void PacketizeThread( packetizer_thread_t *p_pack )
 247 {
 248     sout_buffer_t   *p_sout_buffer;
 249     pes_packet_t    *p_pes;
 250     ssize_t          i_size;
 251
 252     /* **** get samples count **** */
 253     input_ExtractPES( p_pack->p_fifo, &p_pes );
 254     if( !p_pes )
 255     {
 256         p_pack->p_fifo->b_error = 1;
 257         return;
 258     }
 259     if( p_pack->i_pts_start < 0 )
 260     {
 261         p_pack->i_pts_start = p_pes->i_pts;
 262     }
 263
 264     i_size = p_pes->i_pes_size;
 265     if( i_size > 0 )
 266     {
 267         pes_packet_t    *p_pes_next;
 268         data_packet_t   *p_data;
 269         ssize_t          i_buffer;
 270
 271         p_sout_buffer =
 272             sout_BufferNew( p_pack->p_sout_input->p_sout, i_size );
 273         if( !p_sout_buffer )
 274         {
 275             p_pack->p_fifo->b_error = 1;
 276             return;
 277         }
 278         /* TODO: memcpy of the pes packet */
 279         for( i_buffer = 0, p_data = p_pes->p_first;
 280              p_data != NULL && i_buffer < i_size;
 281              p_data = p_data->p_next)
 282         {
 283             ssize_t i_copy;
 284
 285             i_copy = __MIN( p_data->p_payload_end - p_data->p_payload_start,
 286                             i_size - i_buffer );
 287             if( i_copy > 0 )
 288             {
 289                 p_pack->p_fifo->p_vlc->pf_memcpy( p_sout_buffer->p_buffer + i_buffer,
 290                                                   p_data->p_payload_start,
 291                                                   i_copy );
 292             }
 293             i_buffer += i_copy;
 294         }
 295         p_sout_buffer->i_length = 0;
 296         p_sout_buffer->i_dts = p_pes->i_pts - p_pack->i_pts_start;
 297         p_sout_buffer->i_pts = p_pes->i_pts - p_pack->i_pts_start;
 298         p_sout_buffer->i_bitrate = 0;
 299
 300         if( p_pack->p_vol == NULL )
 301         {
 302             uint8_t *p_vol_begin, *p_vol_end, *p_end;
 303             /* search if p_sout_buffer contains with a vol */
 304             p_vol_begin = p_sout_buffer->p_buffer;
 305             p_vol_end   = NULL;
 306             p_end       = p_sout_buffer->p_buffer + p_sout_buffer->i_size;
 307
 308             for( ;; )
 309             {
 310                 if( m4v_FindStartCode( &p_vol_begin, p_end ) )
 311                 {
 312                     break;
 313                 }
 314                 msg_Dbg( p_pack->p_fifo,
 315                           "starcode 0x%2.2x%2.2x%2.2x%2.2x",
 316                           p_vol_begin[0], p_vol_begin[1], p_vol_begin[2], p_vol_begin[3] );
 317
 318                 if( ( p_vol_begin[3] & ~VIDEO_OBJECT_MASK ) == ( VIDEO_OBJECT_START_CODE&0xff ) )
 319                 {
 320                     p_vol_end = p_vol_begin + 4;
 321                     if( m4v_FindStartCode( &p_vol_end, p_end ) )
 322                     {
 323                         break;
 324                     }
 325                     if( ( p_vol_end[3] & ~VIDEO_OBJECT_LAYER_MASK ) == ( VIDEO_OBJECT_LAYER_START_CODE&0xff ) )
 326                     {
 327                         p_vol_end += 4;
 328                         if( m4v_FindStartCode( &p_vol_end, p_end ) )
 329                         {
 330                             p_vol_end = p_end;
 331                         }
 332                     }
 333                     else
 334                     {
 335                         p_vol_end = NULL;
 336                     }
 337                 }
 338                 else if( ( p_vol_begin[3] & ~VIDEO_OBJECT_LAYER_MASK ) == ( VIDEO_OBJECT_LAYER_START_CODE&0xff) )
 339                 {
 340                     p_vol_end = p_vol_begin + 4;
 341                     if( m4v_FindStartCode( &p_vol_end, p_end ) )
 342                     {
 343                         p_vol_end = p_end;
 344                     }
 345                 }
 346
 347                 if( p_vol_end != NULL && p_vol_begin < p_vol_end )
 348                 {
 349                     BITMAPINFOHEADER *p_bih;
 350
 351                     p_pack->i_vol = p_vol_end - p_vol_begin;
 352                     msg_Dbg( p_pack->p_fifo, "Reopening output" );
 353
 354                     p_pack->p_vol = malloc( p_pack->i_vol );
 355                     memcpy( p_pack->p_vol, p_vol_begin, p_pack->i_vol );
 356
 357                     sout_InputDelete( p_pack->p_sout_input );
 358
 359                     p_pack->output_format.i_cat = VIDEO_ES;
 360                     p_pack->output_format.i_fourcc = VLC_FOURCC( 'm', 'p', '4', 'v' );
 361                     p_pack->output_format.p_format =
 362                         (void*)p_bih = malloc( sizeof( BITMAPINFOHEADER ) + p_pack->i_vol);
 363
 364                     p_bih->biSize = sizeof( BITMAPINFOHEADER ) + p_pack->i_vol;
 365                     p_bih->biWidth  = 0;
 366                     p_bih->biHeight = 0;
 367                     p_bih->biPlanes = 1;
 368                     p_bih->biBitCount = 24;
 369                     p_bih->biCompression = VLC_FOURCC( 'd', 'i', 'v', 'x' );
 370                     p_bih->biSizeImage = 0;
 371                     p_bih->biXPelsPerMeter = 0;
 372                     p_bih->biYPelsPerMeter = 0;
 373                     p_bih->biClrUsed = 0;
 374                     p_bih->biClrImportant = 0;
 375                     memcpy( &p_bih[1], p_pack->p_vol, p_pack->i_vol );
 376
 377                     p_pack->p_sout_input =
 378                         sout_InputNew( p_pack->p_fifo,
 379                                        &p_pack->output_format );
 380                     if( !p_pack->p_sout_input )
 381                     {
 382                         p_pack->p_fifo->b_error = 1;
 383                         return;
 384                     }
 385
 386                     break;
 387                 }
 388                 else
 389                 {
 390                     p_vol_begin += 4;
 391                 }
 392             }
 393         }
 394
 395         input_ShowPES( p_pack->p_fifo, &p_pes_next );
 396         if( p_pes_next )
 397         {
 398             mtime_t i_gap;
 399
 400             i_gap = p_pes_next->i_pts - p_pes->i_pts;
 401 #if 0
 402             if( i_gap > 1000000 / 4 )  // too littl fps < 4 is no sense
 403             {
 404                 i_gap = 1000000 / 25;
 405                 p_pack->i_pts_start =
 406                     - ( p_pes->i_pts - p_pack->i_pts_start ) + p_pes_next->i_pts - i_gap;
 407
 408             }
 409             else if( i_gap < 0 )
 410             {
 411                 p_pack->i_pts_start =
 412                     ( p_pes->i_pts - p_pack->i_pts_start ) + p_pes_next->i_pts;
 413                 i_gap = 0;
 414             }
 415             if( i_gap < 0 )
 416             {
 417                 msg_Dbg( p_pack->p_fifo, "pts:%lld next_pts:%lld", p_pes->i_pts, p_pes_next->i_pts );
 418                 /* work around for seek */
 419                 p_pack->i_pts_start -= i_gap;
 420             }
 421
 422 //            msg_Dbg( p_pack->p_fifo, "gap %lld date %lld next diff %lld", i_gap, p_pes->i_pts,  p_pes_next->i_pts-p_pack->i_pts_start );
 423 #endif
 424             p_sout_buffer->i_length = i_gap;
 425         }
 426         sout_InputSendBuffer( p_pack->p_sout_input,
 427                                p_sout_buffer );
 428     }
 429
 430     input_DeletePES( p_pack->p_fifo->p_packets_mgt, p_pes );
 431 }
 432
 433
 434 /*****************************************************************************
 435  * EndThread : packetizer thread destruction
 436  *****************************************************************************/
 437 static void EndThread ( packetizer_thread_t *p_pack)
 438 {
 439     if( p_pack->p_sout_input )
 440     {
 441         sout_InputDelete( p_pack->p_sout_input );
 442     }
 443 }
 444
 445 static void input_ShowPES( decoder_fifo_t *p_fifo, pes_packet_t **pp_pes )
 446 {
 447     pes_packet_t *p_pes;
 448
 449     vlc_mutex_lock( &p_fifo->data_lock );
 450
 451     if( p_fifo->p_first == NULL )
 452     {
 453         if( p_fifo->b_die )
 454         {
 455             vlc_mutex_unlock( &p_fifo->data_lock );
 456             if( pp_pes ) *pp_pes = NULL;
 457             return;
 458         }
 459
 460         /* Signal the input thread we're waiting. This is only
 461          * needed in case of slave clock (ES plug-in) but it won't
 462          * harm. */
 463         vlc_cond_signal( &p_fifo->data_wait );
 464
 465         /* Wait for the input to tell us when we received a packet. */
 466         vlc_cond_wait( &p_fifo->data_wait, &p_fifo->data_lock );
 467     }
 468     p_pes = p_fifo->p_first;
 469     vlc_mutex_unlock( &p_fifo->data_lock );
 470
 471     if( pp_pes )
 472     {
 473         *pp_pes = p_pes;
 474     }
 475 }
 476