Replace block_New() with block_Alloc()

diff --git a/include/vlc_block.h b/include/vlc_block.h
index b2b0c816a6bbcfe4caa748adb79702f8bd344116..92dd5ff67a024f67797f13ab9892d737887c4dac 100644 (file)
--- a/include/vlc_block.h
+++ b/include/vlc_block.h
@@ -139,8 +139,6 @@ VLC_API void block_Init( block_t *, void *, size_t );
 VLC_API block_t *block_Alloc( size_t ) VLC_USED VLC_MALLOC;
 VLC_API block_t *block_Realloc( block_t *, ssize_t i_pre, size_t i_body ) VLC_USED;
 
-#define block_New( dummy, size ) block_Alloc(size)
-
 VLC_USED
 static inline block_t *block_Duplicate( block_t *p_block )
 {

diff --git a/include/vlc_filter.h b/include/vlc_filter.h
index b57b7eff75390d03e7ec0e1a1a510d701e8df5ef..f7c5b32f2f028c617fbcf79abf973780c45061e6 100644 (file)
--- a/include/vlc_filter.h
+++ b/include/vlc_filter.h
@@ -209,7 +209,7 @@ static inline void filter_DeleteSubpicture( filter_t *p_filter, subpicture_t *p_
     p_filter->pf_sub_buffer_del( p_filter, p_subpicture );
 }
 
-#define filter_NewAudioBuffer block_New
+#define filter_NewAudioBuffer(f,s) ((f), block_Alloc(s))
 
 /**
  * This function gives all input attachments at once.

diff --git a/modules/access/bd/bd.c b/modules/access/bd/bd.c
index 52e3f48f892e015925e8d6769bd3894c7d4b7f4d..9c598e24f3b9bbd41e32499c4621741034b42d2a 100644 (file)
--- a/modules/access/bd/bd.c
+++ b/modules/access/bd/bd.c
@@ -409,7 +409,7 @@ static int Demux( demux_t *p_demux )
     /* XXX
      * we ensure that the TS packet start at the begining of the buffer,
      * it ensure proper TS parsing */
-    block_t *p_block = block_New( p_demux, i_packets * BD_TS_PACKET_SIZE + BD_TS_PACKET_HEADER );
+    block_t *p_block = block_Alloc( i_packets * BD_TS_PACKET_SIZE + BD_TS_PACKET_HEADER );
     if( !p_block )
         return -1;
 

diff --git a/modules/access/bluray.c b/modules/access/bluray.c
index a9db9c3713b1864b22ad952abb56831ae18bcc0c..da9e31452f29e2446726a6c7bab316406e1af462 100644 (file)
--- a/modules/access/bluray.c
+++ b/modules/access/bluray.c
@@ -1213,7 +1213,7 @@ static int blurayDemux(demux_t *p_demux)
 {
     demux_sys_t *p_sys = p_demux->p_sys;
 
-    block_t *p_block = block_New(p_demux, NB_TS_PACKETS * (int64_t)BD_TS_PACKET_SIZE);
+    block_t *p_block = block_Alloc(NB_TS_PACKETS * (int64_t)BD_TS_PACKET_SIZE);
     if (!p_block) {
         return -1;
     }

diff --git a/modules/access/cdda.c b/modules/access/cdda.c
index ae99f97f5c4e38b896187178bc1bd1e2d11f9ada..d2bdbafc79e30553a32d103effdcdad2e63f2180 100644 (file)
--- a/modules/access/cdda.c
+++ b/modules/access/cdda.c
@@ -262,7 +262,7 @@ static block_t *Block( access_t *p_access )
     if( !p_sys->b_header )
     {
         /* Return only the header */
-        p_block = block_New( p_access, sizeof( WAVEHEADER ) );
+        p_block = block_Alloc( sizeof( WAVEHEADER ) );
         memcpy( p_block->p_buffer, &p_sys->waveheader, sizeof(WAVEHEADER) );
         p_sys->b_header = true;
         return p_block;
@@ -279,7 +279,7 @@ static block_t *Block( access_t *p_access )
         i_blocks = p_sys->i_last_sector - p_sys->i_sector;
 
     /* Do the actual reading */
-    if( !( p_block = block_New( p_access, i_blocks * CDDA_DATA_SIZE ) ) )
+    if( !( p_block = block_Alloc( i_blocks * CDDA_DATA_SIZE ) ) )
     {
         msg_Err( p_access, "cannot get a new block of size: %i",
                  i_blocks * CDDA_DATA_SIZE );

diff --git a/modules/access/dc1394.c b/modules/access/dc1394.c
index 6eef0a065059a4e41838088511e2bb49e6bbbbbb..4d12cf330369a7f48dfa16ac8c52d2429de28060 100644 (file)
--- a/modules/access/dc1394.c
+++ b/modules/access/dc1394.c
@@ -443,8 +443,7 @@ static block_t *GrabVideo( demux_t *p_demux )
         return NULL;
     }
 
-    p_block = block_New( p_demux, p_sys->frame->size[0] *
-                                  p_sys->frame->size[1] * 2 );
+    p_block = block_Alloc( p_sys->frame->size[0] * p_sys->frame->size[1] * 2 );
     if( !p_block )
     {
         msg_Err( p_demux, "Can not get block" );

diff --git a/modules/access/decklink.cpp b/modules/access/decklink.cpp
index 26c80d209a44b2c8d0060ac3670a43e384453c99..dd2e931dc56ec22793bf7f64bb21608e16e153fd 100644 (file)
--- a/modules/access/decklink.cpp
+++ b/modules/access/decklink.cpp
@@ -254,7 +254,7 @@ HRESULT DeckLinkCaptureDelegate::VideoInputFrameArrived(IDeckLinkVideoInputFrame
         const int stride = videoFrame->GetRowBytes();
 
         int bpp = sys->tenbits ? 4 : 2;
-        block_t *video_frame = block_New(demux_, width * height * bpp);
+        block_t *video_frame = block_Alloc(width * height * bpp);
         if (!video_frame)
             return S_OK;
 
@@ -399,7 +399,7 @@ HRESULT DeckLinkCaptureDelegate::VideoInputFrameArrived(IDeckLinkVideoInputFrame
     if (audioFrame) {
         const int bytes = audioFrame->GetSampleFrameCount() * sizeof(int16_t) * sys->channels;
 
-        block_t *audio_frame = block_New(demux_, bytes);
+        block_t *audio_frame = block_Alloc(bytes);
         if (!audio_frame)
             return S_OK;
 

diff --git a/modules/access/dshow/dshow.cpp b/modules/access/dshow/dshow.cpp
index 60c782d6641e1f1709738b0398c98f06e3a2d83c..84b9977f6f4d2d736856b6d7e79e3d285a29f455 100644 (file)
--- a/modules/access/dshow/dshow.cpp
+++ b/modules/access/dshow/dshow.cpp
@@ -1817,7 +1817,7 @@ static block_t *ReadCompressed( access_t *p_access )
         uint8_t *p_data;
         int i_data_size = sample.p_sample->GetActualDataLength();
 
-        if( !i_data_size || !(p_block = block_New( p_access, i_data_size )) )
+        if( !i_data_size || !(p_block = block_Alloc( i_data_size )) )
         {
             sample.p_sample->Release();
             continue;
@@ -1912,7 +1912,7 @@ static int Demux( demux_t *p_demux )
                      i_stream, i_data_size, i_pts );
 #endif
 
-            p_block = block_New( p_demux, i_data_size );
+            p_block = block_Alloc( i_data_size );
             memcpy( p_block->p_buffer, p_data, i_data_size );
             p_block->i_pts = p_block->i_dts = i_pts;
             sample.p_sample->Release();

diff --git a/modules/access/dtv/bdagraph.cpp b/modules/access/dtv/bdagraph.cpp
index 48661c7c35b007083814d75918cd9e1576380546..ae3d306bd4e6ecfdefe6ccfb8daf5c035b6a98e8 100644 (file)
--- a/modules/access/dtv/bdagraph.cpp
+++ b/modules/access/dtv/bdagraph.cpp
@@ -2822,7 +2822,7 @@ STDMETHODIMP BDAGraph::SampleCB( double /*date*/, IMediaSample *p_sample )
 
     if( i_sample_size > 0 && p_sample_data )
     {
-        block_t *p_block = block_New( p_access, i_sample_size );
+        block_t *p_block = block_Alloc( i_sample_size );
 
         if( p_block )
         {

diff --git a/modules/access/dv.c b/modules/access/dv.c
index d94fc3b4da3d3d4c81d79506ff282d211593233a..91dff44bc6ea7be2519407cd92e39dacfce3edf1 100644 (file)
--- a/modules/access/dv.c
+++ b/modules/access/dv.c
@@ -402,7 +402,7 @@ Raw1394Handler(raw1394handle_t handle, unsigned char *data,
                 block_ChainAppend( &p_sys->p_frame, p_sys->p_ev->p_frame );
             }
             /* reset list */
-            p_sys->p_ev->p_frame = block_New( p_access, 144000 );
+            p_sys->p_ev->p_frame = block_Alloc( 144000 );
             p_sys->p_ev->pp_last = &p_sys->p_frame;
             vlc_mutex_unlock( &p_sys->lock );
         }

diff --git a/modules/access/dvb/access.c b/modules/access/dvb/access.c
index dbe24eb8df87048a910f5e13c89ba65612ba1232..808a533060ee5cf1be4fb7055ff943c256d9d742 100644 (file)
--- a/modules/access/dvb/access.c
+++ b/modules/access/dvb/access.c
@@ -338,7 +338,7 @@ static block_t *BlockScan( access_t *p_access )
         if ( ufds[0].revents )
         {
             const int i_read_once = 1;
-            block_t *p_block = block_New( p_access, i_read_once * TS_PACKET_SIZE );
+            block_t *p_block = block_Alloc( i_read_once * TS_PACKET_SIZE );
 
             if( ( i_ret = read( p_sys->i_handle, p_block->p_buffer,
                                 i_read_once * TS_PACKET_SIZE ) ) <= 0 )

diff --git a/modules/access/dvdnav.c b/modules/access/dvdnav.c
index d89d2e54780953771936bbf44a118f27c44c8591..af4f8f88020320be805a7fb4387ddc5c41f91a55 100644 (file)
--- a/modules/access/dvdnav.c
+++ b/modules/access/dvdnav.c
@@ -1162,7 +1162,7 @@ static int DemuxBlock( demux_t *p_demux, const uint8_t *p, int len )
         }
 
         /* Create a block */
-        block_t *p_pkt = block_New( p_demux, i_size );
+        block_t *p_pkt = block_Alloc( i_size );
         memcpy( p_pkt->p_buffer, p, i_size);
 
         /* Parse it and send it */

diff --git a/modules/access/dvdread.c b/modules/access/dvdread.c
index c806117592201fbb703158414dd80e668b2a9fd9..93c3c29bc65172a00a0e16c2b1f91245d7f8aa92 100644 (file)
--- a/modules/access/dvdread.c
+++ b/modules/access/dvdread.c
@@ -565,7 +565,7 @@ static int DemuxBlock( demux_t *p_demux, const uint8_t *p, int len )
         }
 
         /* Create a block */
-        block_t *p_pkt = block_New( p_demux, i_size );
+        block_t *p_pkt = block_Alloc( i_size );
         memcpy( p_pkt->p_buffer, p, i_size);
 
         /* Parse it and send it */

diff --git a/modules/access/eyetv.m b/modules/access/eyetv.m
index d3ac992b9d5665178f9fed667c0bba3660f97e54..c74df0d9ea182e50be41af4721ab88c52c1d2735 100644 (file)
--- a/modules/access/eyetv.m
+++ b/modules/access/eyetv.m
@@ -259,7 +259,7 @@ static block_t *BlockRead(access_t *p_access)
         return NULL;
 
     /* Read data */
-    p_block = block_New(p_access, MTU);
+    p_block = block_Alloc(MTU);
     len = net_Read(p_access, p_sys->eyetvSock, NULL,
                     p_block->p_buffer, MTU, false);
 

diff --git a/modules/access/imem.c b/modules/access/imem.c
index e5776bc4a99ea8419a55e32f221112995ac80304..6c1bd735c0b51375ffde5d85d455c04c31c9b87f 100644 (file)
--- a/modules/access/imem.c
+++ b/modules/access/imem.c
@@ -384,7 +384,7 @@ static block_t *Block(access_t *access)
 
     block_t *block = NULL;
     if (buffer_size > 0) {
-        block = block_New(access, buffer_size);
+        block = block_Alloc(buffer_size);
         if (block)
             memcpy(block->p_buffer, buffer, buffer_size);
     }
@@ -584,7 +584,7 @@ static int Demux(demux_t *demux)
             dts = pts;
 
         if (buffer_size > 0) {
-            block_t *block = block_New(demux, buffer_size);
+            block_t *block = block_Alloc(buffer_size);
             if (block) {
                 block->i_dts = dts >= 0 ? (1 + dts) : VLC_TS_INVALID;
                 block->i_pts = pts >= 0 ? (1 + pts) : VLC_TS_INVALID;

diff --git a/modules/access/jack.c b/modules/access/jack.c
index f766901773d9d5d593d422bb1a5ffc707cfd107c..c68e63241c89855a2b83c9e8b2467d349b070036 100644 (file)
--- a/modules/access/jack.c
+++ b/modules/access/jack.c
@@ -463,7 +463,7 @@ static block_t *GrabJack( demux_t *p_demux )
     }
     else
     {
-        p_block = block_New( p_demux, i_read );
+        p_block = block_Alloc( i_read );
     }
     if( !p_block )
     {

diff --git a/modules/access/linsys/linsys_hdsdi.c b/modules/access/linsys/linsys_hdsdi.c
index bc480eeaaf4b6f1675148c86e1ec5e46fba6567d..e140b7f23a737b5f7b8d0d5a81499aeede8929b1 100644 (file)
--- a/modules/access/linsys/linsys_hdsdi.c
+++ b/modules/access/linsys/linsys_hdsdi.c
@@ -539,7 +539,7 @@ static int InitAudio( demux_t *p_demux )
 static int HandleVideo( demux_t *p_demux, const uint8_t *p_buffer )
 {
     demux_sys_t *p_sys = p_demux->p_sys;
-    block_t *p_current_picture = block_New( p_demux, p_sys->i_vblock_size );
+    block_t *p_current_picture = block_Alloc( p_sys->i_vblock_size );
     if( unlikely( !p_current_picture ) )
         return VLC_ENOMEM;
     uint8_t *p_y = p_current_picture->p_buffer;
@@ -609,7 +609,7 @@ static int HandleAudio( demux_t *p_demux, const uint8_t *p_buffer )
         hdsdi_audio_t *p_audio = &p_sys->p_audios[i];
         if ( p_audio->i_channel != -1 && p_audio->p_es != NULL )
         {
-            block_t *p_block = block_New( p_demux, p_sys->i_ablock_size );
+            block_t *p_block = block_Alloc( p_sys->i_ablock_size );
             if( unlikely( !p_block ) )
                 return VLC_ENOMEM;
             SparseCopy( (int16_t *)p_block->p_buffer, (const int16_t *)p_buffer,

diff --git a/modules/access/linsys/linsys_sdi.c b/modules/access/linsys/linsys_sdi.c
index dd8a4f9b383573164ccdcc523e986f8a6ebe6931..059614d804c8bb0f9e67d81ddf774efedd6a4e22 100644 (file)
--- a/modules/access/linsys/linsys_sdi.c
+++ b/modules/access/linsys/linsys_sdi.c
@@ -410,7 +410,7 @@ static int NewFrame( demux_t *p_demux )
 {
     demux_sys_t *p_sys = p_demux->p_sys;
 
-    p_sys->p_current_picture = block_New( p_demux, p_sys->i_block_size );
+    p_sys->p_current_picture = block_Alloc( p_sys->i_block_size );
     if( unlikely( !p_sys->p_current_picture ) )
         return VLC_ENOMEM;
     p_sys->p_y = p_sys->p_current_picture->p_buffer;
@@ -801,8 +801,7 @@ static int DecodeTelx( demux_t *p_demux )
         int i_nb_slices_rounded = 3 + (i_nb_slices / 4) * 4;
         int i;
         uint8_t *p;
-        block_t *p_block = block_New( p_demux,
-                                      1 + i_nb_slices_rounded * 46 );
+        block_t *p_block = block_Alloc( 1 + i_nb_slices_rounded * 46 );
         if( unlikely( !p_block ) )
             return VLC_ENOMEM;
         p_block->p_buffer[0] = 0x10; /* FIXME ? data_identifier */
@@ -939,7 +938,7 @@ static int DecodeAudio( demux_t *p_demux, sdi_audio_t *p_audio )
         return VLC_EGENERIC;
     }
 
-    p_block = block_New( p_demux, p_audio->i_nb_samples * sizeof(int16_t) * 2 );
+    p_block = block_Alloc( p_audio->i_nb_samples * sizeof(int16_t) * 2 );
     if( unlikely( !p_block ) )
         return VLC_ENOMEM;
     p_block->i_dts = p_block->i_pts = p_sys->i_next_date

diff --git a/modules/access/mms/mmsh.c b/modules/access/mms/mmsh.c
index ea8e1b14b3f3fc6ff5fc520c08331e8780132537..2a2e85e4165fc7f1fb99ecc42a5815f02bc85e6d 100644 (file)
--- a/modules/access/mms/mmsh.c
+++ b/modules/access/mms/mmsh.c
@@ -345,7 +345,7 @@ static block_t *Block( access_t *p_access )
         const size_t i_offset = p_access->info.i_pos - p_sys->i_start;
         const size_t i_copy = p_sys->i_header - i_offset;
 
-        block_t *p_block = block_New( p_access, i_copy );
+        block_t *p_block = block_Alloc( i_copy );
         if( !p_block )
             return NULL;
 
@@ -364,7 +364,7 @@ static block_t *Block( access_t *p_access )
         if( __MAX( p_sys->i_packet_used, p_sys->i_packet_length ) < i_packet_min )
             i_padding = i_packet_min - __MAX( p_sys->i_packet_used, p_sys->i_packet_length );
 
-        block_t *p_block = block_New( p_access, i_copy + i_padding );
+        block_t *p_block = block_Alloc( i_copy + i_padding );
         if( !p_block )
             return NULL;
 

diff --git a/modules/access/mms/mmstu.c b/modules/access/mms/mmstu.c
index 3a0f2a2fd6adf42d4f6b738fe6cd25b994847050..932c59fc2d3d6c35f5e22e9cde36fb404a3473e6 100644 (file)
--- a/modules/access/mms/mmstu.c
+++ b/modules/access/mms/mmstu.c
@@ -412,7 +412,7 @@ static block_t *Block( access_t *p_access )
     {
         const size_t i_copy = p_sys->i_header - p_access->info.i_pos;
 
-        block_t *p_block = block_New( p_access, i_copy );
+        block_t *p_block = block_Alloc( i_copy );
         if( !p_block )
             return NULL;
 
@@ -430,7 +430,7 @@ static block_t *Block( access_t *p_access )
         if( __MAX( p_sys->i_media, p_sys->i_media_used ) < p_sys->i_packet_length )
             i_padding = p_sys->i_packet_length - __MAX( p_sys->i_media, p_sys->i_media_used );
 
-        block_t *p_block = block_New( p_access, i_copy + i_padding );
+        block_t *p_block = block_Alloc( i_copy + i_padding );
         if( !p_block )
             return NULL;
 

diff --git a/modules/access/oss.c b/modules/access/oss.c
index 672e0437fd2b164debef9181ff2b6e713dc95f19..04d06d0f5f794377e9fb1b8e11b6b941f9c0bee1 100644 (file)
--- a/modules/access/oss.c
+++ b/modules/access/oss.c
@@ -294,7 +294,7 @@ static block_t* GrabAudio( demux_t *p_demux )
     block_t *p_block;
 
     if( p_sys->p_block ) p_block = p_sys->p_block;
-    else p_block = block_New( p_demux, p_sys->i_max_frame_size );
+    else p_block = block_Alloc( p_sys->i_max_frame_size );
 
     if( !p_block )
     {

diff --git a/modules/access/qtcapture.m b/modules/access/qtcapture.m
index 5d90184fee1f360528550c886870a560f664f6ef..e181c644c113ebc82df61670b96f8baea012566e 100644 (file)
--- a/modules/access/qtcapture.m
+++ b/modules/access/qtcapture.m
@@ -417,7 +417,7 @@ static int Demux(demux_t *p_demux)
     demux_sys_t *p_sys = p_demux->p_sys;
     block_t *p_block;
 
-    p_block = block_New(p_demux, p_sys->width * p_sys->height * 2 /* FIXME */);
+    p_block = block_Alloc(p_sys->width * p_sys->height * 2 /* FIXME */);
     if (!p_block) {
         msg_Err(p_demux, "cannot get block");
         return 0;

diff --git a/modules/access/qtsound.m b/modules/access/qtsound.m
index 7119308e0ee596603570786690b50329b0dce8cd..4ff12309927591b749e40ccca9227fe6ba293711 100644 (file)
--- a/modules/access/qtsound.m
+++ b/modules/access/qtsound.m
@@ -502,7 +502,7 @@ static int Demux(demux_t *p_demux)
     block_t *p_blocka;
     NSAutoreleasePool *pool;
 
-    p_blocka = block_New(p_demux, p_sys->i_audio_max_buffer_size);
+    p_blocka = block_Alloc(p_sys->i_audio_max_buffer_size);
 
     if(!p_blocka) {
         msg_Err(p_demux, "cannot get audio block");

diff --git a/modules/access/rtsp/access.c b/modules/access/rtsp/access.c
index bd1bbc393b70271df6cbdfa477933a7b9a299959..611117d5762de6cc117884dcb6d5116219e0f6e9 100644 (file)
--- a/modules/access/rtsp/access.c
+++ b/modules/access/rtsp/access.c
@@ -230,7 +230,7 @@ static int Open( vlc_object_t *p_this )
             goto error;
         }
 
-        p_sys->p_header = block_New( p_access, 4096 );
+        p_sys->p_header = block_Alloc( 4096 );
         p_sys->p_header->i_buffer =
             rmff_dump_header( h, (char *)p_sys->p_header->p_buffer, 1024 );
         rmff_free_header( h );
@@ -283,7 +283,7 @@ static block_t *BlockRead( access_t *p_access )
     i_size = real_get_rdt_chunk_header( p_access->p_sys->p_rtsp, &pheader );
     if( i_size <= 0 ) return NULL;
 
-    p_block = block_New( p_access, i_size );
+    p_block = block_Alloc( i_size );
     p_block->i_buffer = real_get_rdt_chunk( p_access->p_sys->p_rtsp, &pheader,
                                             &p_block->p_buffer );
 

diff --git a/modules/access/screen/mac.c b/modules/access/screen/mac.c
index 91aab767315cbeaa7f789841db1f4b84ca96334d..f26f24e9aa76364e4f339743806d01c60f37cffe 100644 (file)
--- a/modules/access/screen/mac.c
+++ b/modules/access/screen/mac.c
@@ -325,7 +325,7 @@ block_t *screen_Capture( demux_t *p_demux )
 
     i_size = p_sys->fmt.video.i_height * p_sys->fmt.video.i_width * 4;
 
-    if( !( p_block = block_New( p_demux, i_size ) ) )
+    if( !( p_block = block_Alloc( i_size ) ) )
     {
         msg_Warn( p_demux, "cannot get block" );
         return NULL;

diff --git a/modules/access/sftp.c b/modules/access/sftp.c
index d0768025cebe09b353db523967415a3ee5727d34..5920b2192eacb45495821600aecaa734a4045661 100644 (file)
--- a/modules/access/sftp.c
+++ b/modules/access/sftp.c
@@ -277,7 +277,7 @@ static block_t* Block( access_t* p_access )
     /* Allocate the buffer we need */
     size_t i_len = __MIN( p_access->p_sys->i_read_size, p_access->info.i_size -
                                               p_access->info.i_pos );
-    block_t* p_block = block_New( p_access, i_len );
+    block_t* p_block = block_Alloc( i_len );
     if( !p_block )
         return NULL;
 

diff --git a/modules/access/udp.c b/modules/access/udp.c
index bad325bbeb791ca8e1369cc3b564c19f8de960b1..6818ef3682e8c158d40db21fc07e4df32fd94bad 100644 (file)
--- a/modules/access/udp.c
+++ b/modules/access/udp.c
@@ -206,7 +206,7 @@ static block_t *BlockUDP( access_t *p_access )
         return NULL;
 
     /* Read data */
-    p_block = block_New( p_access, MTU );
+    p_block = block_Alloc( MTU );
     len = net_Read( p_access, (intptr_t)p_sys, NULL,
                     p_block->p_buffer, MTU, false );
     if( len < 0 )

diff --git a/modules/access/vcd/vcd.c b/modules/access/vcd/vcd.c
index c51651c55875c1f02018fb311e2c81e617a5be2f..63201369bc8f66f272c2fdaf07fb5aafcc2a6818 100644 (file)
--- a/modules/access/vcd/vcd.c
+++ b/modules/access/vcd/vcd.c
@@ -351,7 +351,7 @@ static block_t *Block( access_t *p_access )
     }
 
     /* Do the actual reading */
-    if( i_blocks < 0 || !( p_block = block_New( p_access, i_blocks * VCD_DATA_SIZE ) ) )
+    if( i_blocks < 0 || !( p_block = block_Alloc( i_blocks * VCD_DATA_SIZE ) ) )
     {
         msg_Err( p_access, "cannot get a new block of size: %i",
                  i_blocks * VCD_DATA_SIZE );

diff --git a/modules/access/vcdx/access.c b/modules/access/vcdx/access.c
index 0f1e49566e15f96ebdfaa02c3af6adcf56c7437f..7c25ac3d0f3f8199cd4cf1ef0c280137ec502ce4 100644 (file)
--- a/modules/access/vcdx/access.c
+++ b/modules/access/vcdx/access.c
@@ -150,7 +150,7 @@ VCDReadBlock( access_t * p_access )
                (long unsigned int) p_vcdplayer->i_lsn );
 
     /* Allocate a block for the reading */
-    if( !( p_block = block_New( p_access, i_blocks * M2F2_SECTOR_SIZE ) ) )
+    if( !( p_block = block_Alloc( i_blocks * M2F2_SECTOR_SIZE ) ) )
     {
         msg_Err( p_access, "cannot get a new block of size: %i",
                  i_blocks * M2F2_SECTOR_SIZE );

diff --git a/modules/codec/a52.c b/modules/codec/a52.c
index 4bf592dffe7c02304ac171d032a331bdca9537bc..4fec50c7c073dbb5d2228062cd957be81f2dee40 100644 (file)
--- a/modules/codec/a52.c
+++ b/modules/codec/a52.c
@@ -400,7 +400,7 @@ static block_t *GetSoutBuffer( decoder_t *p_dec )
 {
     decoder_sys_t *p_sys = p_dec->p_sys;
 
-    block_t *p_block = block_New( p_dec, p_sys->frame.i_size );
+    block_t *p_block = block_Alloc( p_sys->frame.i_size );
     if( p_block )
     {
         p_block->i_pts = p_block->i_dts = date_Get( &p_sys->end_date );

diff --git a/modules/codec/avcodec/encoder.c b/modules/codec/avcodec/encoder.c
index 62147ea8133cd3c7bbb72b18fa1c3455f2c3af3e..54b7fed93e39211f2e0bcac4a0a1cebab0d8f002 100644 (file)
--- a/modules/codec/avcodec/encoder.c
+++ b/modules/codec/avcodec/encoder.c
@@ -854,7 +854,7 @@ static block_t *EncodeVideo( encoder_t *p_enc, picture_t *p_pict )
     const int bytesPerPixel = p_enc->fmt_out.video.i_bits_per_pixel ?
                          p_enc->fmt_out.video.i_bits_per_pixel / 8 : 3;
     const int blocksize = __MAX( FF_MIN_BUFFER_SIZE,bytesPerPixel * p_sys->p_context->height * p_sys->p_context->width + 200 );
-    block_t *p_block = block_New( p_enc, blocksize );
+    block_t *p_block = block_Alloc( blocksize );
 
     if( likely(p_pict) ) {
         AVFrame *frame;
@@ -1035,7 +1035,7 @@ static block_t *EncodeAudio( encoder_t *p_enc, block_t *p_aout_buf )
     {
         msg_Dbg(p_enc,"Flushing..");
         do {
-            p_block = block_New( p_enc, p_sys->i_buffer_out );
+            p_block = block_Alloc( p_sys->i_buffer_out );
             av_init_packet( &packet );
             packet.data = p_block->p_buffer;
             packet.size = p_block->i_buffer;
@@ -1058,7 +1058,7 @@ static block_t *EncodeAudio( encoder_t *p_enc, block_t *p_aout_buf )
 
     frame->pts = p_aout_buf->i_pts;
 
-    p_block = block_New( p_enc, p_sys->i_buffer_out );
+    p_block = block_Alloc( p_sys->i_buffer_out );
     av_init_packet( &packet );
     packet.data = p_block->p_buffer;
     packet.size = p_block->i_buffer;

diff --git a/modules/codec/dirac.c b/modules/codec/dirac.c
index 5c62f4ef0de95063dbd112c437cfc0adff657f55..b10fd721e5b2b1915604a677f8917743bf0b9615 100644 (file)
--- a/modules/codec/dirac.c
+++ b/modules/codec/dirac.c
@@ -855,7 +855,7 @@ static block_t *Encode( encoder_t *p_enc, picture_t *p_pic )
 
     /* store dts in a queue, so that they appear in order in
      * coded order */
-    p_block = block_New( p_enc, 1 );
+    p_block = block_Alloc( 1 );
     if( !p_block )
         return NULL;
     p_block->i_dts = p_pic->date - p_sys->i_pts_offset;
@@ -870,7 +870,7 @@ static block_t *Encode( encoder_t *p_enc, picture_t *p_pic )
         StorePicturePTS( p_enc, p_sys->i_input_picnum, p_pic->date + p_sys->i_field_time );
         p_sys->i_input_picnum++;
 
-        p_block = block_New( p_enc, 1 );
+        p_block = block_Alloc( 1 );
         if( !p_block )
             return NULL;
         p_block->i_dts = p_pic->date - p_sys->i_pts_offset + p_sys->i_field_time;
@@ -891,7 +891,7 @@ static block_t *Encode( encoder_t *p_enc, picture_t *p_pic )
             uint32_t pic_num;
 
             /* extract data from encoder temporary buffer. */
-            p_block = block_New( p_enc, p_sys->p_dirac->enc_buf.size );
+            p_block = block_Alloc( p_sys->p_dirac->enc_buf.size );
             if( !p_block )
                 return NULL;
             memcpy( p_block->p_buffer, p_sys->p_dirac->enc_buf.buffer,

diff --git a/modules/codec/dmo/dmo.c b/modules/codec/dmo/dmo.c
index 401e6218b49e1ad6c749f0430aa1eaf20eeabe8c..b95874f078fa0b4dc4e963c0d1a1a825f579cd1a 100644 (file)
--- a/modules/codec/dmo/dmo.c
+++ b/modules/codec/dmo/dmo.c
@@ -1542,7 +1542,7 @@ static block_t *EncodeBlock( encoder_t *p_enc, void *p_data )
             p_enc->fmt_in.video.i_height *
             p_enc->fmt_in.video.i_bits_per_pixel / 8;
 
-        p_block_in = block_New( p_enc, i_buffer );
+        p_block_in = block_Alloc( i_buffer );
 
         /* Copy picture stride by stride */
         p_dst = p_block_in->p_buffer;
@@ -1566,7 +1566,7 @@ static block_t *EncodeBlock( encoder_t *p_enc, void *p_data )
     else
     {
         block_t *p_aout_buffer = (block_t *)p_data;
-        p_block_in = block_New( p_enc, p_aout_buffer->i_buffer );
+        p_block_in = block_Alloc( p_aout_buffer->i_buffer );
         memcpy( p_block_in->p_buffer, p_aout_buffer->p_buffer,
                 p_block_in->i_buffer );
 
@@ -1609,7 +1609,7 @@ static block_t *EncodeBlock( encoder_t *p_enc, void *p_data )
         block_t *p_block_out;
         CMediaBuffer *p_out;
 
-        p_block_out = block_New( p_enc, p_sys->i_min_output );
+        p_block_out = block_Alloc( p_sys->i_min_output );
         p_block_out->i_buffer = 0;
         p_out = CMediaBufferCreate(p_block_out, p_sys->i_min_output, false);
         memset( &db, 0, sizeof(db) );

diff --git a/modules/codec/dts.c b/modules/codec/dts.c
index d6f25fce30af547524fe879b01f9a7b5e065e338..8559642ad1bcf564df0f6bfd4200d0bdc7307232 100644 (file)
--- a/modules/codec/dts.c
+++ b/modules/codec/dts.c
@@ -425,7 +425,7 @@ static block_t *GetSoutBuffer( decoder_t *p_dec )
     decoder_sys_t *p_sys = p_dec->p_sys;
     block_t *p_block;
 
-    p_block = block_New( p_dec, p_sys->i_frame_size );
+    p_block = block_Alloc( p_sys->i_frame_size );
     if( p_block == NULL ) return NULL;
 
     p_block->i_pts = p_block->i_dts = date_Get( &p_sys->end_date );

diff --git a/modules/codec/dvbsub.c b/modules/codec/dvbsub.c
index 52784408db795d107fe109c915d6cd415058592e..5ab6071f46329d9d35d45198f86336424a419e09 100644 (file)
--- a/modules/codec/dvbsub.c
+++ b/modules/codec/dvbsub.c
@@ -1994,7 +1994,7 @@ static block_t *Encode( encoder_t *p_enc, subpicture_t *p_subpic )
 #ifdef DEBUG_DVBSUB
     msg_Dbg( p_enc, "encoding subpicture" );
 #endif
-    p_block = block_New( p_enc, 64000 );
+    p_block = block_Alloc( 64000 );
     bs_init( s, p_block->p_buffer, p_block->i_buffer );
 
     bs_write( s, 8, 0x20 ); /* Data identifier */
@@ -2021,7 +2021,7 @@ static block_t *Encode( encoder_t *p_enc, subpicture_t *p_subpic )
         p_block->i_length = p_subpic->i_stop - p_subpic->i_start;
 
         /* Send another (empty) subtitle to signal the end of display */
-        p_block_stop = block_New( p_enc, 64000 );
+        p_block_stop = block_Alloc( 64000 );
         bs_init( s, p_block_stop->p_buffer, p_block_stop->i_buffer );
         bs_write( s, 8, 0x20 ); /* Data identifier */
         bs_write( s, 8, 0x0 );  /* Subtitle stream id */

diff --git a/modules/codec/fdkaac.c b/modules/codec/fdkaac.c
index d4c40cc3374031f30a049f6b515de48a91eea5ff..19a4ca5f263e23c0d696de7e8c027fe2b1db643a 100644 (file)
--- a/modules/codec/fdkaac.c
+++ b/modules/codec/fdkaac.c
@@ -434,7 +434,7 @@ static block_t *EncodeAudio( encoder_t *p_enc, block_t *p_aout_buf )
             in_buf.bufElSizes = &in_elem_size;
         }
         block_t *p_block;
-        p_block = block_New( p_enc, p_sys->i_maxoutputsize );
+        p_block = block_Alloc( p_sys->i_maxoutputsize );
         p_block->i_buffer = p_sys->i_maxoutputsize;
         out_ptr = p_block->p_buffer;
         out_size = p_block->i_buffer;

diff --git a/modules/codec/flac.c b/modules/codec/flac.c
index 8f25eefde64c637710bdce851f7545f717c60847..eea32b881eb2389527c5f59129920b822021ab2a 100644 (file)
--- a/modules/codec/flac.c
+++ b/modules/codec/flac.c
@@ -452,7 +452,7 @@ static void ProcessHeader( decoder_t *p_dec )
 
     /* Decode STREAMINFO */
     msg_Dbg( p_dec, "decode STREAMINFO" );
-    p_sys->p_block = block_New( p_dec, p_dec->fmt_in.i_extra );
+    p_sys->p_block = block_Alloc( p_dec->fmt_in.i_extra );
     memcpy( p_sys->p_block->p_buffer, p_dec->fmt_in.p_extra,
             p_dec->fmt_in.i_extra );
     FLAC__stream_decoder_process_until_end_of_metadata( p_sys->p_flac );
@@ -641,7 +641,7 @@ EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
     }
 
-    p_block = block_New( p_enc, bytes );
+    p_block = block_Alloc( bytes );
     memcpy( p_block->p_buffer, buffer, bytes );
 
     p_block->i_dts = p_block->i_pts = p_sys->i_pts;

diff --git a/modules/codec/libmpeg2.c b/modules/codec/libmpeg2.c
index b391a3dbc8fcb97ea8a569c3cd0ef9e96536c6c4..928c8aa02c325acc43f344566b38ccb71e2d0bc7 100644 (file)
--- a/modules/codec/libmpeg2.c
+++ b/modules/codec/libmpeg2.c
@@ -703,7 +703,7 @@ static block_t *GetCc( decoder_t *p_dec, bool pb_present[4] )
     if( p_sys->cc.i_data <= 0 )
         return NULL;
 
-    p_cc = block_New( p_dec, p_sys->cc.i_data);
+    p_cc = block_Alloc( p_sys->cc.i_data);
     if( p_cc )
     {
         memcpy( p_cc->p_buffer, p_sys->cc.p_data, p_sys->cc.i_data );

diff --git a/modules/codec/lpcm.c b/modules/codec/lpcm.c
index eb7284d5c0d6512c1ce5e6d05bacf86a9f8d5127..aa36f0cfac689836b5d485f496189199e39919c7 100644 (file)
--- a/modules/codec/lpcm.c
+++ b/modules/codec/lpcm.c
@@ -542,7 +542,7 @@ static block_t *EncodeFrames( encoder_t *p_enc, block_t *p_aout_buf )
 
     for ( int i = 0; i < i_num_frames; ++i )
     {
-        block_t *p_block = block_New( p_enc, i_frame_size );
+        block_t *p_block = block_Alloc( i_frame_size );
         if( !p_block )
             return NULL;
 

diff --git a/modules/codec/mpeg_audio.c b/modules/codec/mpeg_audio.c
index 453b25606ef1f2cbff59bae2d19e1acdf978a610..8c300cda131141c22d38f2ccea4609d0404665fb 100644 (file)
--- a/modules/codec/mpeg_audio.c
+++ b/modules/codec/mpeg_audio.c
@@ -552,7 +552,7 @@ static block_t *GetSoutBuffer( decoder_t *p_dec )
     decoder_sys_t *p_sys = p_dec->p_sys;
     block_t *p_block;
 
-    p_block = block_New( p_dec, p_sys->i_frame_size );
+    p_block = block_Alloc( p_sys->i_frame_size );
     if( p_block == NULL ) return NULL;
 
     p_block->i_pts = p_block->i_dts = date_Get( &p_sys->end_date );

diff --git a/modules/codec/omxil/omxil.c b/modules/codec/omxil/omxil.c
index a3f0af3e2bb7973468d59961e6376341bddf28fb..7794dee7a62a9ba3e35a69e79358553b962be008 100644 (file)
--- a/modules/codec/omxil/omxil.c
+++ b/modules/codec/omxil/omxil.c
@@ -1614,7 +1614,7 @@ static block_t *EncodeVideo( encoder_t *p_enc, picture_t *p_pic )
             {
                 /* We're not in direct rendering mode.
                  * Get a new block and copy the content */
-                p_block = block_New( p_dec, p_header->nFilledLen );
+                p_block = block_Alloc( p_header->nFilledLen );
                 memcpy(p_block->p_buffer, p_header->pBuffer, p_header->nFilledLen );
             }
 

diff --git a/modules/codec/schroedinger.c b/modules/codec/schroedinger.c
index d36a757a6911ad16775c0609af44fe5c74a05174..0c5a7e74b999d2f518f2009a3568a603d037ec37 100644 (file)
--- a/modules/codec/schroedinger.c
+++ b/modules/codec/schroedinger.c
@@ -1483,7 +1483,7 @@ static block_t *Encode( encoder_t *p_enc, picture_t *p_pic )
 
         /* store dts in a queue, so that they appear in order in
          * coded order */
-        p_block = block_New( p_enc, 1 );
+        p_block = block_Alloc( 1 );
         if( !p_block )
             return NULL;
         p_block->i_dts = p_pic->date - p_sys->i_pts_offset;
@@ -1497,7 +1497,7 @@ static block_t *Encode( encoder_t *p_enc, picture_t *p_pic )
             StorePicturePTS( p_enc, p_sys->i_input_picnum, p_pic->date + p_sys->i_field_time );
             p_sys->i_input_picnum++;
 
-            p_block = block_New( p_enc, 1 );
+            p_block = block_Alloc( 1 );
             if( !p_block )
                 return NULL;
             p_block->i_dts = p_pic->date - p_sys->i_pts_offset + p_sys->i_field_time;
@@ -1527,7 +1527,7 @@ static block_t *Encode( encoder_t *p_enc, picture_t *p_pic )
             uint32_t u_pic_num;
             int i_presentation_frame;
             p_enc_buf = schro_encoder_pull( p_sys->p_schro, &i_presentation_frame );
-            p_block = block_New( p_enc, p_enc_buf->length );
+            p_block = block_Alloc( p_enc_buf->length );
             if( !p_block )
                 return NULL;
 

diff --git a/modules/codec/shine/shine_mod.c b/modules/codec/shine/shine_mod.c
index 3f897e5f56da2c3a40ff487c75364f17bc81fe31..925e22dcb1d141b97c6e20504ee705aef3875b6c 100644 (file)
--- a/modules/codec/shine/shine_mod.c
+++ b/modules/codec/shine/shine_mod.c
@@ -148,7 +148,7 @@ static block_t *GetPCM( encoder_t *p_enc, block_t *p_block )
     while( p_sys->i_buffer + p_block->i_buffer >= pcm_chunk_size )
     {
         unsigned int i_buffer = 0;
-        p_pcm_block = block_New( p_enc, pcm_chunk_size );
+        p_pcm_block = block_Alloc( pcm_chunk_size );
         if( !p_pcm_block )
             break;
 
@@ -224,7 +224,7 @@ static block_t *EncodeFrame( encoder_t *p_enc, block_t *p_block )
         encode_frame( (char*)p_pcm_block->p_buffer, chunk );
         block_Release( p_pcm_block );
 
-        block_t *p_mp3_block = block_New( p_enc, chunk->enc_size );
+        block_t *p_mp3_block = block_Alloc( chunk->enc_size );
         if( !p_mp3_block )
             break;
 

diff --git a/modules/codec/speex.c b/modules/codec/speex.c
index daadcf2a0a24e756a87b0b315dc85efcf7c8f4c7..94fc27e1e4131ff5dd2c91866594b0e7971470fd 100644 (file)
--- a/modules/codec/speex.c
+++ b/modules/codec/speex.c
@@ -508,7 +508,7 @@ static void *ProcessPacket( decoder_t *p_dec, ogg_packet *p_oggpacket,
                 (8 - (i_bits_in_speex_frame % 8)) )
                     / 8;
 
-                p_new_block = block_New( p_dec, i_bytes_in_speex_frame );
+                p_new_block = block_Alloc( i_bytes_in_speex_frame );
             memset( p_new_block->p_buffer, 0xff, i_bytes_in_speex_frame );
 
             /*
@@ -1053,7 +1053,7 @@ static block_t *Encode( encoder_t *p_enc, block_t *p_aout_buf )
                                   MAX_FRAME_BYTES );
         speex_bits_reset( &p_sys->bits );
 
-        p_block = block_New( p_enc, i_out );
+        p_block = block_Alloc( i_out );
         memcpy( p_block->p_buffer, p_sys->p_buffer_out, i_out );
 
         p_block->i_length = (mtime_t)1000000 *

diff --git a/modules/codec/subsusf.c b/modules/codec/subsusf.c
index 41bcafffdb564613439f589c7e5981a6eb0795d3..74a9cf765c9cf9a5425250a6a23c91c71dbf51a6 100644 (file)
--- a/modules/codec/subsusf.c
+++ b/modules/codec/subsusf.c
@@ -514,7 +514,7 @@ static int ParseImageAttachments( decoder_t *p_dec )
             {
                 block_t   *p_block;
 
-                p_block = block_New( p_image->p_parent, p_attach->i_data );
+                p_block = block_Alloc( p_attach->i_data );
 
                 if( p_block != NULL )
                 {

diff --git a/modules/codec/t140.c b/modules/codec/t140.c
index 1a3fc2acdbd83f69919c199d741834ce965f7267..babbd47d440def485ce81aee3ea5e16933e0ca24 100644 (file)
--- a/modules/codec/t140.c
+++ b/modules/codec/t140.c
@@ -98,7 +98,7 @@ static block_t *Encode( encoder_t *p_enc, subpicture_t *p_spu )
 
     /* This should already be UTF-8 encoded, so not much effort... */
     len = strlen( p_region->psz_text );
-    p_block = block_New( p_enc, len );
+    p_block = block_Alloc( len );
     memcpy( p_block->p_buffer, p_region->psz_text, len );
 
     p_block->i_pts = p_block->i_dts = p_spu->i_start;

diff --git a/modules/codec/theora.c b/modules/codec/theora.c
index 7e2854f14ca1f22f3963086d6f7b4bb7cc56c25b..a052b4627c33db68597e0a527e16593d3ab20634 100644 (file)
--- a/modules/codec/theora.c
+++ b/modules/codec/theora.c
@@ -850,7 +850,7 @@ static block_t *Encode( encoder_t *p_enc, picture_t *p_pict )
     th_encode_packetout( p_sys->tcx, 0, &oggpacket );
 
     /* Ogg packet to block */
-    p_block = block_New( p_enc, oggpacket.bytes );
+    p_block = block_Alloc( oggpacket.bytes );
     memcpy( p_block->p_buffer, oggpacket.packet, oggpacket.bytes );
     p_block->i_dts = p_block->i_pts = p_pict->date;
 

diff --git a/modules/codec/twolame.c b/modules/codec/twolame.c
index cb8862d6b78ec9487e2de71a737827f9c62fe6f4..092fd7db8a35c1e8e4617cf370c7ff84d0f31053 100644 (file)
--- a/modules/codec/twolame.c
+++ b/modules/codec/twolame.c
@@ -286,7 +286,7 @@ static block_t *Encode( encoder_t *p_enc, block_t *p_aout_buf )
                                p_sys->p_buffer, MPEG_FRAME_SIZE,
                                p_sys->p_out_buffer, MAX_CODED_FRAME_SIZE );
         p_sys->i_nb_samples = 0;
-        p_block = block_New( p_enc, i_used );
+        p_block = block_Alloc( i_used );
         memcpy( p_block->p_buffer, p_sys->p_out_buffer, i_used );
         p_block->i_length = (mtime_t)1000000 *
                 (mtime_t)MPEG_FRAME_SIZE / (mtime_t)p_enc->fmt_out.audio.i_rate;

diff --git a/modules/codec/vorbis.c b/modules/codec/vorbis.c
index 1768a768ff5e9b3b3b81cfb5547325c2866b76e0..e57de44583bba1336fa5828ca4a9fbadcb9e7b1b 100644 (file)
--- a/modules/codec/vorbis.c
+++ b/modules/codec/vorbis.c
@@ -880,7 +880,7 @@ static block_t *Encode( encoder_t *p_enc, block_t *p_aout_buf )
         while( vorbis_bitrate_flushpacket( &p_sys->vd, &oggpacket ) )
         {
             int i_block_size;
-            p_block = block_New( p_enc, oggpacket.bytes );
+            p_block = block_Alloc( oggpacket.bytes );
             memcpy( p_block->p_buffer, oggpacket.packet, oggpacket.bytes );
 
             i_block_size = vorbis_packet_blocksize( &p_sys->vi, &oggpacket );

diff --git a/modules/codec/x264.c b/modules/codec/x264.c
index 7074dc03fed5cc200d07721e78843b39d5e73fd2..6c5051fbaa3f73a62833147644da91fce38921e1 100644 (file)
--- a/modules/codec/x264.c
+++ b/modules/codec/x264.c
@@ -1475,7 +1475,7 @@ static block_t *Encode( encoder_t *p_enc, picture_t *p_pict )
     for( i = 0; i < i_nal; i++ )
         i_out += nal[i].i_payload;
 
-    p_block = block_New( p_enc, i_out + p_sys->i_sei_size );
+    p_block = block_Alloc( i_out + p_sys->i_sei_size );
     if( !p_block ) return NULL;
 
     unsigned int i_offset = 0;

diff --git a/modules/demux/avformat/demux.c b/modules/demux/avformat/demux.c
index b683a97fff31facc4146b9ec81ad47463493bed1..b09fad820684586cc7ab3125fa62d0e72e750f9c 100644 (file)
--- a/modules/demux/avformat/demux.c
+++ b/modules/demux/avformat/demux.c
@@ -616,7 +616,7 @@ static int Demux( demux_t *p_demux )
     }
     else
     {
-        if( ( p_frame = block_New( p_demux, pkt.size ) ) == NULL )
+        if( ( p_frame = block_Alloc( pkt.size ) ) == NULL )
         {
             av_free_packet( &pkt );
             return 0;

diff --git a/modules/demux/avformat/mux.c b/modules/demux/avformat/mux.c
index 8effe755687af8977f2cf1072f69b7210d2f8840..56596b87c41d864390d21deff81ff062ab0a4b96 100644 (file)
--- a/modules/demux/avformat/mux.c
+++ b/modules/demux/avformat/mux.c
@@ -401,7 +401,7 @@ static int IOWrite( void *opaque, uint8_t *buf, int buf_size )
     msg_Dbg( p_mux, "IOWrite %i bytes", buf_size );
 #endif
 
-    block_t *p_buf = block_New( p_mux->p_sout, buf_size );
+    block_t *p_buf = block_Alloc( buf_size );
     if( buf_size > 0 ) memcpy( p_buf->p_buffer, buf, buf_size );
 
     if( p_mux->p_sys->b_write_header )

diff --git a/modules/demux/image.c b/modules/demux/image.c
index a2b7372b0b163874d43b44a129142189cabcd7dd..672e7ba49eb1b31069cacd8cb8f134edb5c16090 100644 (file)
--- a/modules/demux/image.c
+++ b/modules/demux/image.c
@@ -150,7 +150,7 @@ static block_t *Decode(demux_t *demux,
         size += image->p[i].i_visible_pitch *
                 image->p[i].i_visible_lines;
 
-    data = block_New(demux, size);
+    data = block_Alloc(size);
     if (!data) {
         picture_Release(image);
         return NULL;

diff --git a/modules/demux/live555.cpp b/modules/demux/live555.cpp
index ba3c1cd390bb787bae5cd4042ae6ca6c4f269921..a75b135bde62a6347803e7f31b2cac3bb360a9a8 100644 (file)
--- a/modules/demux/live555.cpp
+++ b/modules/demux/live555.cpp
@@ -1718,7 +1718,7 @@ static block_t *StreamParseAsf( demux_t *p_demux, live_track_t *tk,
 
         if( !tk->p_asf_block )
         {
-            tk->p_asf_block = block_New( p_demux, i_packet_size );
+            tk->p_asf_block = block_Alloc( i_packet_size );
             if( !tk->p_asf_block )
                 break;
             tk->p_asf_block->i_buffer = 0;
@@ -1880,7 +1880,7 @@ static void StreamRead( void *p_private, unsigned int i_size,
     {
         AMRAudioSource *amrSource = (AMRAudioSource*)tk->sub->readSource();
 
-        p_block = block_New( p_demux, i_size + 1 );
+        p_block = block_Alloc( i_size + 1 );
         p_block->p_buffer[0] = amrSource->lastFrameHeader();
         memcpy( p_block->p_buffer + 1, tk->p_buffer, i_size );
     }
@@ -1888,7 +1888,7 @@ static void StreamRead( void *p_private, unsigned int i_size,
     {
         H261VideoRTPSource *h261Source = (H261VideoRTPSource*)tk->sub->rtpSource();
         uint32_t header = h261Source->lastSpecialHeader();
-        p_block = block_New( p_demux, i_size + 4 );
+        p_block = block_Alloc( i_size + 4 );
         memcpy( p_block->p_buffer, &header, 4 );
         memcpy( p_block->p_buffer + 4, tk->p_buffer, i_size );
 
@@ -1901,7 +1901,7 @@ static void StreamRead( void *p_private, unsigned int i_size,
             msg_Warn( p_demux, "unsupported NAL type for H264" );
 
         /* Normal NAL type */
-        p_block = block_New( p_demux, i_size + 4 );
+        p_block = block_Alloc( i_size + 4 );
         p_block->p_buffer[0] = 0x00;
         p_block->p_buffer[1] = 0x00;
         p_block->p_buffer[2] = 0x00;
@@ -1916,7 +1916,7 @@ static void StreamRead( void *p_private, unsigned int i_size,
     }
     else
     {
-        p_block = block_New( p_demux, i_size );
+        p_block = block_Alloc( i_size );
         memcpy( p_block->p_buffer, tk->p_buffer, i_size );
     }
 
@@ -2066,7 +2066,7 @@ static int ParseASF( demux_t *p_demux )
     }
 
     /* Always smaller */
-    p_header = block_New( p_demux, psz_end - psz_asf );
+    p_header = block_Alloc( psz_end - psz_asf );
     p_header->i_buffer = vlc_b64_decode_binary_to_buffer( p_header->p_buffer,
                                                p_header->i_buffer, psz_asf );
     //msg_Dbg( p_demux, "Size=%d Hdrb64=%s", p_header->i_buffer, psz_asf );

diff --git a/modules/demux/mkv/util.cpp b/modules/demux/mkv/util.cpp
index 758335a0bddde2a833385bd3d1c40d2d87168393..7eea9a049b81df3b019f462a6d95bee0920b9a13 100644 (file)
--- a/modules/demux/mkv/util.cpp
+++ b/modules/demux/mkv/util.cpp
@@ -121,7 +121,7 @@ block_t *block_zlib_decompress( vlc_object_t *p_this, block_t *p_in_block ) {
     d_stream.next_in = (Bytef *)p_in_block->p_buffer;
     d_stream.avail_in = p_in_block->i_buffer;
     n = 0;
-    p_block = block_New( p_this, 0 );
+    p_block = block_Alloc( 0 );
     dst = NULL;
     do
     {
@@ -159,7 +159,7 @@ block_t *MemToBlock( uint8_t *p_mem, size_t i_mem, size_t offset)
     if( unlikely( i_mem > SIZE_MAX - offset ) )
         return NULL;
 
-    block_t *p_block = block_New( p_demux, i_mem + offset );
+    block_t *p_block = block_Alloc( i_mem + offset );
     if( likely(p_block != NULL) )
     {
         memcpy( p_block->p_buffer + offset, p_mem, i_mem );
@@ -198,7 +198,7 @@ void handle_real_audio(demux_t * p_demux, mkv_track_t * p_tk, block_t * p_blk, m
             if( i_index >= p_sys->i_subpackets )
                 return;
 
-            block_t *p_block = block_New( p_demux, p_sys->i_subpacket_size );
+            block_t *p_block = block_Alloc( p_sys->i_subpacket_size );
             if( !p_block )
                 return;
 

diff --git a/modules/demux/mod.c b/modules/demux/mod.c
index 2ccb30389c2d89f35c9abdf30d0f81132475dab1..aa4adef74c5ee7e9d5c60fc0312bc5e3be4df0ca 100644 (file)
--- a/modules/demux/mod.c
+++ b/modules/demux/mod.c
@@ -266,7 +266,7 @@ static int Demux( demux_t *p_demux )
     const int i_bk = ( p_sys->fmt.audio.i_bitspersample / 8 ) *
                        p_sys->fmt.audio.i_channels;
 
-    p_frame = block_New( p_demux, p_sys->fmt.audio.i_rate / 10 * i_bk );
+    p_frame = block_Alloc( p_sys->fmt.audio.i_rate / 10 * i_bk );
     if( !p_frame )
         return -1;
 

diff --git a/modules/demux/mpc.c b/modules/demux/mpc.c
index 649a93e72ef8b95c0911edec1c4eb1f72c5b1210..989eca49c7be41b2768563f98eb64ff69b0a2dbb 100644 (file)
--- a/modules/demux/mpc.c
+++ b/modules/demux/mpc.c
@@ -247,8 +247,7 @@ static int Demux( demux_t *p_demux )
     mpc_frame_info frame;
     mpc_status err;
 #endif
-    p_data = block_New( p_demux,
-                        MPC_DECODER_BUFFER_LENGTH*sizeof(MPC_SAMPLE_FORMAT) );
+    p_data = block_Alloc( MPC_DECODER_BUFFER_LENGTH*sizeof(MPC_SAMPLE_FORMAT) );
     if( !p_data )
         return -1;
 

diff --git a/modules/demux/ogg.c b/modules/demux/ogg.c
index 52bf76bbbfa74a9b6f09675400c3008ad8be0750..c26fbd92f2c7ec57d240770784dca67ac0ef0d34 100644 (file)
--- a/modules/demux/ogg.c
+++ b/modules/demux/ogg.c
@@ -872,7 +872,7 @@ static void Ogg_DecodePacket( demux_t *p_demux,
         return;
     }
 
-    if( !( p_block = block_New( p_demux, p_oggpacket->bytes ) ) ) return;
+    if( !( p_block = block_Alloc( p_oggpacket->bytes ) ) ) return;
 
 
     /* may need to preroll after a seek */

diff --git a/modules/demux/rawdv.h b/modules/demux/rawdv.h
index c698205a2743776aa605580a16ba1c99b8f6eb1c..347384e0e51554eb97397fa932b8b079168d2d8e 100644 (file)
--- a/modules/demux/rawdv.h
+++ b/modules/demux/rawdv.h
@@ -138,7 +138,7 @@ static block_t *dv_extract_audio( block_t *p_frame_block )
 
     i_samples = dv_get_audio_sample_count( &p_buf[1], i_dsf );
 
-    p_block = block_New( p_demux, 4 * i_samples );
+    p_block = block_Alloc( 4 * i_samples );
 
     /* for each DIF segment */
     p_frame = p_frame_block->p_buffer;

diff --git a/modules/demux/real.c b/modules/demux/real.c
index 06f9f3a9bb453e94699e8824f964a3ecbaf7ce54..ebf031baf423e62348482b50133973751593e83a 100644 (file)
--- a/modules/demux/real.c
+++ b/modules/demux/real.c
@@ -547,7 +547,7 @@ static void DemuxVideo( demux_t *p_demux, real_track_t *tk, mtime_t i_dts, unsig
             if( tk->p_frame )
                 block_Release( tk->p_frame );
 
-            tk->p_frame = block_New( p_demux, tk->i_frame_size );
+            tk->p_frame = block_Alloc( tk->i_frame_size );
             if( !tk->p_frame )
             {
                 tk->i_frame_size = 0;
@@ -638,7 +638,7 @@ static void DemuxAudioMethod1( demux_t *p_demux, real_track_t *tk, mtime_t i_pts
             if( i_index >= tk->i_subpackets )
                 return;
 
-            block_t *p_block = block_New( p_demux, tk->i_subpacket_size );
+            block_t *p_block = block_Alloc( tk->i_subpacket_size );
             if( !p_block )
                 return;
             if( &p_buf[tk->i_subpacket_size] > &p_sys->buffer[p_sys->i_buffer] )
@@ -673,7 +673,7 @@ static void DemuxAudioMethod1( demux_t *p_demux, real_track_t *tk, mtime_t i_pts
             if( i_index >= tk->i_subpackets )
                 return;
 
-            block_t *p_block = block_New( p_demux, tk->i_coded_frame_size);
+            block_t *p_block = block_Alloc( tk->i_coded_frame_size);
             if( !p_block )
                 return;
             if( &p_buf[tk->i_coded_frame_size] > &p_sys->buffer[p_sys->i_buffer] )
@@ -745,7 +745,7 @@ static void DemuxAudioMethod2( demux_t *p_demux, real_track_t *tk, mtime_t i_pts
     for( unsigned i = 0; i < i_sub; i++ )
     {
         const int i_sub_size = GetWBE( &p_sys->buffer[2+i*2] );
-        block_t *p_block = block_New( p_demux, i_sub_size );
+        block_t *p_block = block_Alloc( i_sub_size );
         if( !p_block )
             break;
 
@@ -769,7 +769,7 @@ static void DemuxAudioMethod3( demux_t *p_demux, real_track_t *tk, mtime_t i_pts
     if( p_sys->i_buffer <= 0 )
         return;
 
-    block_t *p_block = block_New( p_demux, p_sys->i_buffer );
+    block_t *p_block = block_Alloc( p_sys->i_buffer );
     if( !p_block )
         return;
 
@@ -846,7 +846,7 @@ static void DemuxAudioSipr( demux_t *p_demux, real_track_t *tk, mtime_t i_pts )
 
     if( !p_block )
     {
-        p_block = block_New( p_demux, tk->i_frame_size * tk->i_subpacket_h );
+        p_block = block_Alloc( tk->i_frame_size * tk->i_subpacket_h );
         if( !p_block )
             return;
         tk->p_sipr_packet = p_block;

diff --git a/modules/demux/sid.cpp b/modules/demux/sid.cpp
index e93b55b5b58b4cc2cf956bc2244dc523dba145e0..b901b98ba7c0097d61f238fbd2f36218b6b63195 100644 (file)
--- a/modules/demux/sid.cpp
+++ b/modules/demux/sid.cpp
@@ -206,7 +206,7 @@ static int Demux (demux_t *demux)
 {
     demux_sys_t *sys = demux->p_sys;
 
-    block_t *block = block_New( p_demux, sys->block_size);
+    block_t *block = block_Alloc( sys->block_size);
     if (unlikely(block==NULL))
         return 0;
 

diff --git a/modules/demux/smf.c b/modules/demux/smf.c
index e7e93e9bed77746ea56bd5a2ed354f0c18877de6..bc75fa28f407469cb6227df93d6be57d02c39e86 100644 (file)
--- a/modules/demux/smf.c
+++ b/modules/demux/smf.c
@@ -525,7 +525,7 @@ int HandleMessage (demux_t *p_demux, mtrk_t *tr)
     }
 
     /* FIXME: one message per block is very inefficient */
-    block = block_New (p_demux, 1 + datalen);
+    block = block_Alloc (1 + datalen);
     if (block == NULL)
         goto skip;
 
@@ -603,7 +603,7 @@ static int Demux (demux_t *p_demux)
     /* MIDI Tick emulation (ping the decoder every 10ms) */
     while (cur_tick < last_tick)
     {
-        block_t *tick = block_New (p_demux, 1);
+        block_t *tick = block_Alloc (1);
         if (tick == NULL)
             break;
 

diff --git a/modules/demux/subtitle.c b/modules/demux/subtitle.c
index eb2cc4d29c410e3050ccfefaa842316349a29190..aa1c7e66128ab3da2dd9fef6c66a5f2ec2a3285d 100644 (file)
--- a/modules/demux/subtitle.c
+++ b/modules/demux/subtitle.c
@@ -689,7 +689,7 @@ static int Demux( demux_t *p_demux )
             continue;
         }
 
-        if( ( p_block = block_New( p_demux, i_len ) ) == NULL )
+        if( ( p_block = block_Alloc( i_len ) ) == NULL )
         {
             p_sys->i_subtitle++;
             continue;

diff --git a/modules/demux/ty.c b/modules/demux/ty.c
index c2fc281422fed0655e30c3a218cbb1d86480edbd..9ff31ecd77c85ec51ca7252a65a6cb8e9e867542 100644 (file)
--- a/modules/demux/ty.c
+++ b/modules/demux/ty.c
@@ -798,7 +798,7 @@ static int DemuxRecVideo( demux_t *p_demux, ty_rec_hdr_t *rec_hdr, block_t *p_bl
         {
             if( p_sys->p_cc[i] )
             {
-                block_t *p_cc = block_New( p_demux, p_sys->cc.i_data );
+                block_t *p_cc = block_Alloc( p_sys->cc.i_data );
                 p_cc->i_flags |= BLOCK_FLAG_TYPE_I;
                 p_cc->i_pts = p_block_in->i_pts;
                 memcpy( p_cc->p_buffer, p_sys->cc.p_data, p_sys->cc.i_data );

diff --git a/modules/demux/vobsub.c b/modules/demux/vobsub.c
index e4274b85b7f94a9feca9e9cda23f64be8664ee40..780da72da0832168dc738d59385d40dca461caba 100644 (file)
--- a/modules/demux/vobsub.c
+++ b/modules/demux/vobsub.c
@@ -387,7 +387,7 @@ static int Demux( demux_t *p_demux )
             }
 
             /* allocate a packet */
-            if( ( p_block = block_New( p_demux, i_size ) ) == NULL )
+            if( ( p_block = block_Alloc( i_size ) ) == NULL )
             {
                 tk.i_current_subtitle++;
                 continue;
@@ -674,7 +674,7 @@ static int DemuxVobSub( demux_t *p_demux, block_t *p_bk )
         }
 
         /* Create a block */
-        p_pkt = block_New( p_demux, i_size );
+        p_pkt = block_Alloc( i_size );
         if( unlikely(p_pkt == NULL) )
             break;
         memcpy( p_pkt->p_buffer, p, i_size);

diff --git a/modules/demux/voc.c b/modules/demux/voc.c
index f89dbdc00da96409f93653c35c67c976343d45d6..af4f1633daa07e418d6818d19fb78dce833dba04 100644 (file)
--- a/modules/demux/voc.c
+++ b/modules/demux/voc.c
@@ -458,7 +458,7 @@ static int Demux( demux_t *p_demux )
         if( i > SAMPLES_BUFFER )
             i = SAMPLES_BUFFER;
 
-        p_block = block_New( p_demux, i );
+        p_block = block_Alloc( i );
         if( p_block == NULL )
             return VLC_ENOMEM;
 

diff --git a/modules/misc/rtsp.c b/modules/misc/rtsp.c
index 8829c0a22799cbc714cf4bd30070252bbeba3b1c..784f8b0db6e12c7e61b9ee7a0930f13cc4a263fc 100644 (file)
--- a/modules/misc/rtsp.c
+++ b/modules/misc/rtsp.c
@@ -755,7 +755,7 @@ static void CommandPush( vod_t *p_vod, rtsp_cmd_type_t i_type, vod_media_t *p_me
     if( psz_arg )
         cmd.psz_arg = strdup(psz_arg);
 
-    p_cmd = block_New( p_vod, sizeof(rtsp_cmd_t) );
+    p_cmd = block_Alloc( sizeof(rtsp_cmd_t) );
     memcpy( p_cmd->p_buffer, &cmd, sizeof(cmd) );
 
     block_FifoPut( p_vod->p_sys->p_fifo_cmd, p_cmd );

diff --git a/modules/misc/stats/encoder.c b/modules/misc/stats/encoder.c
index 84b5cd7aada33ed032fcc22ecf68852bd58c1a72..574c8bb2ebfcdf69908228d573eed8f5e33afa6b 100644 (file)
--- a/modules/misc/stats/encoder.c
+++ b/modules/misc/stats/encoder.c
@@ -75,7 +75,7 @@ int OpenEncoder ( vlc_object_t *p_this )
 static block_t *EncodeVideo( encoder_t *p_enc, picture_t *p_pict )
 {
     (void)p_pict;
-    block_t * p_block = block_New( p_enc, kBufferSize );
+    block_t * p_block = block_Alloc( kBufferSize );
 
     *(mtime_t*)p_block->p_buffer = mdate();
     p_block->i_buffer = kBufferSize;

diff --git a/modules/mux/asf.c b/modules/mux/asf.c
index c2d91e07142d3a9ccd4e534398cf8dee3fd45b49..80df76d3a8359bbcf091afc1a1fe202887c75e3f 100644 (file)
--- a/modules/mux/asf.c
+++ b/modules/mux/asf.c
@@ -909,13 +909,13 @@ static block_t *asf_header_create( sout_mux_t *p_mux, bool b_broadcast )
 
     if( p_sys->b_asf_http )
     {
-        out = block_New( p_mux, i_size + 50 + 12 );
+        out = block_Alloc( i_size + 50 + 12 );
         bo_init( &bo, out->p_buffer, i_size + 50 + 12 );
         asf_chunk_add( &bo, 0x4824, i_size + 50, 0xc00, p_sys->i_seq++ );
     }
     else
     {
-        out = block_New( p_mux, i_size + 50 );
+        out = block_Alloc( i_size + 50 );
         bo_init( &bo, out->p_buffer, i_size + 50 );
     }
 
@@ -1183,7 +1183,7 @@ static block_t *asf_packet_create( sout_mux_t *p_mux,
 
         if( p_sys->pk == NULL )
         {
-            p_sys->pk = block_New( p_mux, p_sys->i_packet_size + i_preheader );
+            p_sys->pk = block_Alloc( p_sys->i_packet_size + i_preheader );
             /* reserve 14 bytes for the packet header */
             p_sys->i_pk_used = 14 + i_preheader;
             p_sys->i_pk_frame = 0;
@@ -1244,14 +1244,14 @@ static block_t *asf_stream_end_create( sout_mux_t *p_mux )
 
     if( p_sys->b_asf_http )
     {
-        out = block_New( p_mux, 12 );
+        out = block_Alloc( 12 );
         bo_init( &bo, out->p_buffer, 12 );
         asf_chunk_add( &bo, 0x4524, 0, 0x00, p_sys->i_seq++ );
     }
     else
     {
         /* Create index */
-        out = block_New( p_mux, 56 );
+        out = block_Alloc( 56 );
         bo_init( &bo, out->p_buffer, 56 );
         bo_add_guid ( &bo, &asf_object_index_guid );
         bo_addle_u64( &bo, 56 );

diff --git a/modules/mux/avi.c b/modules/mux/avi.c
index f418914fee3ff7b5734b97f865cfb6e9bc277764..8ca321f82303a26e0e8f3a13e0d9c334bd51225c 100644 (file)
--- a/modules/mux/avi.c
+++ b/modules/mux/avi.c
@@ -837,7 +837,7 @@ static block_t *avi_HeaderCreateRIFF( sout_mux_t *p_mux )
     int                 i_junk;
     buffer_out_t        bo;
 
-    p_hdr = block_New( p_mux, HDR_SIZE );
+    p_hdr = block_Alloc( HDR_SIZE );
     memset( p_hdr->p_buffer, 0, HDR_SIZE );
 
     bo_Init( &bo, HDR_SIZE, p_hdr->p_buffer );
@@ -882,7 +882,7 @@ static block_t * avi_HeaderCreateidx1( sout_mux_t *p_mux )
 
     i_idx1_size = 16 * p_sys->idx1.i_entry_count + 8;
 
-    p_idx1 = block_New( p_mux, i_idx1_size);
+    p_idx1 = block_Alloc( i_idx1_size);
     memset( p_idx1->p_buffer, 0, i_idx1_size);
 
     bo_Init( &bo, i_idx1_size, p_idx1->p_buffer );

diff --git a/modules/mux/dummy.c b/modules/mux/dummy.c
index e1eec70061635e1c738ca186171676ed0cc0f9e7..f42850f35d92c88075fa7b2ce55f5b30ce17f29e 100644 (file)
--- a/modules/mux/dummy.c
+++ b/modules/mux/dummy.c
@@ -153,7 +153,7 @@ static int Mux( sout_mux_t *p_mux )
         {
             /* Write header data */
             block_t *p_data;
-            p_data = block_New( p_mux, p_mux->pp_inputs[i]->p_fmt->i_extra );
+            p_data = block_Alloc( p_mux->pp_inputs[i]->p_fmt->i_extra );
 
             memcpy( p_data->p_buffer, p_mux->pp_inputs[i]->p_fmt->p_extra,
                     p_mux->pp_inputs[i]->p_fmt->i_extra );

diff --git a/modules/mux/mp4.c b/modules/mux/mp4.c
index 3a1a515fc2bfa04eb16d290c7eaeeab3cb7fe045..9ea54a971f1d21c5fa1dfbf009c3ea5eb18686a8 100644 (file)
--- a/modules/mux/mp4.c
+++ b/modules/mux/mp4.c
@@ -290,7 +290,7 @@ static void Close( vlc_object_t * p_this )
         while( i_size > 0 )
         {
             i_chunk = __MIN( 32768, i_size );
-            p_buf = block_New( p_mux, i_chunk );
+            p_buf = block_Alloc( i_chunk );
             sout_AccessOutSeek( p_mux->p_access,
                                 p_sys->i_mdat_pos + i_size - i_chunk );
             if( sout_AccessOutRead( p_mux->p_access, p_buf ) < i_chunk )
@@ -596,7 +596,7 @@ again:
                 p_stream->i_last_dts += i_length;
 
                 /* Write a " " */
-                p_data = block_New( p_mux, 3 );
+                p_data = block_Alloc( 3 );
                 p_data->p_buffer[0] = 0;
                 p_data->p_buffer[1] = 1;
                 p_data->p_buffer[2] = ' ';

diff --git a/modules/mux/mpeg/ps.c b/modules/mux/mpeg/ps.c
index 2cafbfd9463960e404a271943b992fb58468d0ff..450d301f04f47515d677292fe73d122dfd78b093 100644 (file)
--- a/modules/mux/mpeg/ps.c
+++ b/modules/mux/mpeg/ps.c
@@ -214,7 +214,7 @@ static void Close( vlc_object_t * p_this )
 
     msg_Info( p_mux, "Close" );
 
-    p_end = block_New( p_mux, 4 );
+    p_end = block_Alloc( 4 );
     p_end->p_buffer[0] = 0x00; p_end->p_buffer[1] = 0x00;
     p_end->p_buffer[2] = 0x01; p_end->p_buffer[3] = 0xb9;
 
@@ -574,7 +574,7 @@ static void MuxWritePackHeader( sout_mux_t *p_mux, block_t **p_buf,
 
     i_scr = (i_dts - p_sys->i_dts_delay) * 9 / 100;
 
-    p_hdr = block_New( p_mux, 18 );
+    p_hdr = block_Alloc( 18 );
     p_hdr->i_pts = p_hdr->i_dts = i_dts;
     bits_initwrite( &bits, 14, p_hdr->p_buffer );
     bits_write( &bits, 32, 0x01ba );
@@ -648,7 +648,7 @@ static void MuxWriteSystemHeader( sout_mux_t *p_mux, block_t **p_buf,
     i_nb_stream = p_mux->i_nb_inputs -
         ( i_nb_private > 0 ? i_nb_private - 1 : 0 );
 
-    p_hdr = block_New( p_mux, 12 + i_nb_stream * 3 );
+    p_hdr = block_Alloc(  12 + i_nb_stream * 3 );
     p_hdr->i_dts = p_hdr->i_pts = i_dts;
 
     /* The spec specifies that the reported rate_bound must be upper limit */
@@ -738,7 +738,7 @@ static void MuxWritePSM( sout_mux_t *p_mux, block_t **p_buf, mtime_t i_dts )
 
     i_psm_size += i_es_map_size;
 
-    p_hdr = block_New( p_mux, i_psm_size );
+    p_hdr = block_Alloc( i_psm_size );
     p_hdr->i_dts = p_hdr->i_pts = i_dts;
 
     memset( p_hdr->p_buffer, 0, p_hdr->i_buffer );

diff --git a/modules/mux/mpeg/ts.c b/modules/mux/mpeg/ts.c
index c29dfec948ba44860c6b79f8dae380b3638bb11e..b916730ebcc2d7f73958458887d9a34fae7c0f01 100644 (file)
--- a/modules/mux/mpeg/ts.c
+++ b/modules/mux/mpeg/ts.c
@@ -1321,7 +1321,7 @@ static bool MuxStreams(sout_mux_t *p_mux )
             if( p_data->i_length > 0 &&
                 ( p_data->i_buffer != 1 || *p_data->p_buffer != ' ' ) )
             {
-                block_t *p_spu = block_New( p_mux, 3 );
+                block_t *p_spu = block_Alloc( 3 );
 
                 p_spu->i_dts = p_data->i_dts + p_data->i_length;
                 p_spu->i_pts = p_spu->i_dts;
@@ -1536,7 +1536,7 @@ static block_t *FixPES( sout_mux_t *p_mux, block_fifo_t *p_fifo )
     }
     else if( i_size > STD_PES_PAYLOAD )
     {
-        block_t *p_new = block_New( p_mux, STD_PES_PAYLOAD );
+        block_t *p_new = block_Alloc( STD_PES_PAYLOAD );
         memcpy( p_new->p_buffer, p_data->p_buffer, STD_PES_PAYLOAD );
         p_new->i_pts = p_data->i_pts;
         p_new->i_dts = p_data->i_dts;
@@ -1767,7 +1767,7 @@ static block_t *TSNew( sout_mux_t *p_mux, ts_stream_t *p_stream,
         b_adaptation_field = true;
     }
 
-    block_t *p_ts = block_New( p_mux, 188 );
+    block_t *p_ts = block_Alloc( 188 );
 
     if (b_new_pes && !(p_pes->i_flags & BLOCK_FLAG_NO_KEYFRAME) && p_pes->i_flags & BLOCK_FLAG_TYPE_I)
     {

diff --git a/modules/mux/mpjpeg.c b/modules/mux/mpjpeg.c
index 8d5817529b520787addc7597f1fd4e4b0e86d9ed..275e751b571cecadff86daf09b651595a41be7cc 100644 (file)
--- a/modules/mux/mpjpeg.c
+++ b/modules/mux/mpjpeg.c
@@ -159,7 +159,7 @@ static int Mux( sout_mux_t *p_mux )
             "Content-Length: %zu\r\n"
             "\r\n";
         block_t *p_data = block_FifoGet( p_fifo );
-        block_t *p_header = block_New( p_mux, sizeof( psz_hfmt ) + 20 );
+        block_t *p_header = block_Alloc( sizeof( psz_hfmt ) + 20 );
 
         if( p_header == NULL ) /* uho! */
         {

diff --git a/modules/mux/ogg.c b/modules/mux/ogg.c
index 72805b3653280171471f553fe7b112d91a52a916..8ace9262f642706cbd4258e1c01618a574eabfe3 100644 (file)
--- a/modules/mux/ogg.c
+++ b/modules/mux/ogg.c
@@ -516,7 +516,7 @@ static block_t *OggStreamGetPage( sout_mux_t *p_mux,
     while( pager( p_os, &og ) )
     {
         /* Flush all data */
-        p_og = block_New( p_mux, og.header_len + og.body_len );
+        p_og = block_Alloc( og.header_len + og.body_len );
 
         memcpy( p_og->p_buffer, og.header, og.header_len );
         memcpy( p_og->p_buffer + og.header_len, og.body, og.body_len );

diff --git a/modules/mux/wav.c b/modules/mux/wav.c
index fff319e96c1c200954da9b9f59704c0559d17a38..c1fd87df974dac93f6282e0dfcdfed842245a533 100644 (file)
--- a/modules/mux/wav.c
+++ b/modules/mux/wav.c
@@ -239,7 +239,7 @@ static block_t *GetHeader( sout_mux_t *p_mux )
 {
     sout_mux_sys_t *p_sys = p_mux->p_sys;
     block_t *p_block =
-        block_New( p_mux, sizeof( WAVEFORMATEXTENSIBLE ) + 7 * 4 );
+        block_Alloc( sizeof( WAVEFORMATEXTENSIBLE ) + 7 * 4 );
 
     SetDWLE( &p_sys->waveheader[1],
              20 + (p_sys->b_ext ? 40 : 16) + p_sys->i_data ); /* Length */

diff --git a/modules/packetizer/dirac.c b/modules/packetizer/dirac.c
index 656a37c090a541ac53bf54f190a49da5a2600ef9..9f27185fa8e4891bb13a27eca0e6a090f727faf4 100644 (file)
--- a/modules/packetizer/dirac.c
+++ b/modules/packetizer/dirac.c
@@ -651,7 +651,7 @@ static bool dirac_UnpackSeqHdr( struct seq_hdr_t *p_sh, block_t *p_block )
 static block_t *dirac_EmitEOS( decoder_t *p_dec, uint32_t i_prev_parse_offset )
 {
     const uint8_t p_eos[] = { 'B','B','C','D',0x10,0,0,0,13,0,0,0,0 };
-    block_t *p_block = block_New( p_dec, 13 );
+    block_t *p_block = block_Alloc( 13 );
     if( !p_block )
         return NULL;
     memcpy( p_block->p_buffer, p_eos, 13 );
@@ -797,7 +797,7 @@ sync_fail:
     p_sys->i_offset = 0;
 
     /* setup the data unit buffer */
-    block_t *p_block = block_New( p_dec, pu.u_next_offset );
+    block_t *p_block = block_Alloc( pu.u_next_offset );
     if( !p_block )
         return NULL;
 
@@ -1383,7 +1383,7 @@ static int Open( vlc_object_t *p_this )
         /* handle hacky systems like ogg that dump some headers
          * in p_extra. and packetizers that expect it to be filled
          * in before real startup */
-        block_t *p_init = block_New( p_dec, p_dec->fmt_in.i_extra );
+        block_t *p_init = block_Alloc( p_dec->fmt_in.i_extra );
         if( !p_init )
         {
             /* memory might be avaliable soon.  it isn't the end of

diff --git a/modules/packetizer/flac.c b/modules/packetizer/flac.c
index 7899a519cea6ebaf05148b783f07a3d451236ac7..19de0bfc364dac78c9280d3ba36e8f6d3d1e8523 100644 (file)
--- a/modules/packetizer/flac.c
+++ b/modules/packetizer/flac.c
@@ -348,7 +348,7 @@ static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
             }
 
         case STATE_SEND_DATA:
-            p_sout_block = block_New( p_dec, p_sys->i_frame_size );
+            p_sout_block = block_Alloc( p_sys->i_frame_size );
 
             /* Copy the whole frame into the buffer. When we reach this point
              * we already know we have enough data available. */

diff --git a/modules/packetizer/h264.c b/modules/packetizer/h264.c
index fea0d795c55488a70d8cc58a3279eb5236defd5d..a8193a7cb04aebedc59241694e31f75c74ddde43 100644 (file)
--- a/modules/packetizer/h264.c
+++ b/modules/packetizer/h264.c
@@ -484,7 +484,7 @@ static block_t *GetCc( decoder_t *p_dec, bool pb_present[4] )
     if( p_sys->cc.i_data <= 0 )
         return NULL;
 
-    p_cc = block_New( p_dec, p_sys->cc.i_data);
+    p_cc = block_Alloc( p_sys->cc.i_data);
     if( p_cc )
     {
         memcpy( p_cc->p_buffer, p_sys->cc.p_data, p_sys->cc.i_data );
@@ -538,7 +538,7 @@ static block_t *CreateAnnexbNAL( decoder_t *p_dec, const uint8_t *p, int i_size
 {
     block_t *p_nal;
 
-    p_nal = block_New( p_dec, 4 + i_size );
+    p_nal = block_Alloc( 4 + i_size );
     if( !p_nal ) return NULL;
 
     /* Add start code */

diff --git a/modules/packetizer/mlp.c b/modules/packetizer/mlp.c
index 93d3273859593904a80a4f98a910db41892c4eaa..69b96b6e379487a004165897f004e7acff6055b2 100644 (file)
--- a/modules/packetizer/mlp.c
+++ b/modules/packetizer/mlp.c
@@ -271,7 +271,7 @@ static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
         case STATE_SEND_DATA:
             /* When we reach this point we already know we have enough
              * data available. */
-            p_out_buffer = block_New( p_dec, p_sys->i_frame_size );
+            p_out_buffer = block_Alloc( p_sys->i_frame_size );
             if( !p_out_buffer )
                 return NULL;
 

diff --git a/modules/packetizer/mpeg4audio.c b/modules/packetizer/mpeg4audio.c
index dfa10e9a29fa538a927240d426816b9ffa43565e..41f3216a5cb32d6b07fffdc8bdda08ef41dca983 100644 (file)
--- a/modules/packetizer/mpeg4audio.c
+++ b/modules/packetizer/mpeg4audio.c
@@ -1137,7 +1137,7 @@ static block_t *PacketizeStreamBlock( decoder_t *p_dec, block_t **pp_block )
             /* When we reach this point we already know we have enough
              * data available. */
 
-            p_out_buffer = block_New( p_dec, p_sys->i_frame_size );
+            p_out_buffer = block_Alloc( p_sys->i_frame_size );
             if( !p_out_buffer )
             {
                 //p_dec->b_error = true;

diff --git a/modules/packetizer/mpegvideo.c b/modules/packetizer/mpegvideo.c
index a1bb00cee97dc0e8a986adebe00a74a0d0f45f37..54f12c60334cf6f1131615fc5a82885eb702a75d 100644 (file)
--- a/modules/packetizer/mpegvideo.c
+++ b/modules/packetizer/mpegvideo.c
@@ -265,7 +265,7 @@ static block_t *GetCc( decoder_t *p_dec, bool pb_present[4] )
     if( p_sys->cc.i_data <= 0 )
         return NULL;
 
-    p_cc = block_New( p_dec, p_sys->cc.i_data);
+    p_cc = block_Alloc( p_sys->cc.i_data );
     if( p_cc )
     {
         memcpy( p_cc->p_buffer, p_sys->cc.p_data, p_sys->cc.i_data );

diff --git a/modules/packetizer/packetizer_helper.h b/modules/packetizer/packetizer_helper.h
index bc28d065b08b528ad94f343ab806a750a848b6d3..a06db9337f44e0a9afc1b5bfd56640a9de3621c4 100644 (file)
--- a/modules/packetizer/packetizer_helper.h
+++ b/modules/packetizer/packetizer_helper.h
@@ -163,7 +163,7 @@ static inline block_t *packetizer_Packetize( packetizer_t *p_pack, block_t **pp_
             /* Get the new fragment and set the pts/dts */
             block_t *p_block_bytestream = p_pack->bytestream.p_block;
 
-            p_pic = block_New( p_dec, p_pack->i_offset + p_pack->i_au_prepend );
+            p_pic = block_Alloc( p_pack->i_offset + p_pack->i_au_prepend );
             p_pic->i_pts = p_block_bytestream->i_pts;
             p_pic->i_dts = p_block_bytestream->i_dts;
 

diff --git a/modules/stream_out/rtp.c b/modules/stream_out/rtp.c
index 2f265fcb7c7be8ebd04dbf2bd3eeb3d22de0aad9..25ac644a12bcca702977c2c664710f87d1c7d7da 100644 (file)
--- a/modules/stream_out/rtp.c
+++ b/modules/stream_out/rtp.c
@@ -1742,7 +1742,7 @@ static ssize_t AccessOutGrabberWriteBuffer( sout_stream_t *p_stream,
         if( p_sys->packet == NULL )
         {
             /* allocate a new packet */
-            p_sys->packet = block_New( p_stream, id->i_mtu );
+            p_sys->packet = block_Alloc( id->i_mtu );
             rtp_packetize_common( id, p_sys->packet, 1, i_dts );
             p_sys->packet->i_dts = i_dts;
             p_sys->packet->i_length = p_buffer->i_length / i_packet;

diff --git a/modules/stream_out/rtpfmt.c b/modules/stream_out/rtpfmt.c
index 79ae441226552ef486d410b82513bf8767596edb..7b71588545b3bafd0e558e4455fd887ce3ae843e 100644 (file)
--- a/modules/stream_out/rtpfmt.c
+++ b/modules/stream_out/rtpfmt.c
@@ -1331,7 +1331,7 @@ static int rtp_packetize_g726( sout_stream_id_t *id, block_t *in, int i_pad )
     while( i_data > 0 )
     {
         int           i_payload = __MIN( i_max, i_data );
-        block_t *out = block_New( p_stream, 12 + i_payload );
+        block_t *out = block_Alloc( 12 + i_payload );
 
         /* rtp common header */
         rtp_packetize_common( id, out, 0,

diff --git a/modules/stream_out/switcher.c b/modules/stream_out/switcher.c
index 131ad88b21b883e872f1d3e5fafab4b4def15c85..1aa686b8bfae1a2e2cf67596ae05938b43a21910 100644 (file)
--- a/modules/stream_out/switcher.c
+++ b/modules/stream_out/switcher.c
@@ -925,7 +925,7 @@ static block_t *VideoGetBuffer( sout_stream_t *p_stream, sout_stream_id_t *id,
     }
 #endif
 
-    p_out = block_New( p_stream, i_out );
+    p_out = block_Alloc( i_out );
     memcpy( p_out->p_buffer, id->p_buffer_out, i_out );
     p_out->i_length = p_buffer->i_length;
     p_out->i_pts = p_buffer->i_dts;
@@ -968,7 +968,7 @@ static block_t *AudioGetBuffer( sout_stream_t *p_stream, sout_stream_id_t *id,
     if ( i_out <= 0 )
         return NULL;
 
-    p_out = block_New( p_stream, i_out );
+    p_out = block_Alloc( i_out );
     memcpy( p_out->p_buffer, id->p_buffer_out, i_out );
     p_out->i_length = p_buffer->i_length;
     p_out->i_pts = p_buffer->i_dts;

diff --git a/modules/stream_out/transcode/audio.c b/modules/stream_out/transcode/audio.c
index f2aa2508cb0d70608851da208978713f27192630..4c0bfe8d85d19bacbaf6c5463cd1ca89d47140d3 100644 (file)
--- a/modules/stream_out/transcode/audio.c
+++ b/modules/stream_out/transcode/audio.c
@@ -66,7 +66,7 @@ static block_t *audio_new_buffer( decoder_t *p_dec, int i_samples )
         i_size = i_samples * 4 * p_dec->fmt_out.audio.i_channels;
     }
 
-    p_block = block_New( p_dec, i_size );
+    p_block = block_Alloc( i_size );
     p_block->i_nb_samples = i_samples;
     return p_block;
 }

diff --git a/modules/stream_out/vod.c b/modules/stream_out/vod.c
index dd611d5fa4f581471eedbdbc64e2a78d75a0cbd7..41c8d254253babfd4b3e28d08b29325a4b1f5f8c 100644 (file)
--- a/modules/stream_out/vod.c
+++ b/modules/stream_out/vod.c
@@ -339,7 +339,7 @@ static void CommandPush( vod_t *p_vod, rtsp_cmd_type_t i_type,
     else
         cmd.psz_arg = NULL;
 
-    p_cmd = block_New( p_vod, sizeof(rtsp_cmd_t) );
+    p_cmd = block_Alloc( sizeof(rtsp_cmd_t) );
     memcpy( p_cmd->p_buffer, &cmd, sizeof(cmd) );
 
     block_FifoPut( p_vod->p_sys->p_fifo_cmd, p_cmd );

diff --git a/modules/visualization/goom.c b/modules/visualization/goom.c
index 9e3dcd39bfac078f7a4e34720e164fa197c9dfdd..175c04897a70c85d01250e5be941442644b545e7 100644 (file)
--- a/modules/visualization/goom.c
+++ b/modules/visualization/goom.c
@@ -204,7 +204,7 @@ static block_t *DoWork( filter_t *p_filter, block_t *p_in_buf )
         return p_in_buf;
     }
 
-    p_block = block_New( p_sys->p_thread, p_in_buf->i_buffer );
+    p_block = block_Alloc( p_in_buf->i_buffer );
     if( !p_block )
     {
         vlc_mutex_unlock( &p_sys->p_thread->lock );

diff --git a/src/input/stream.c b/src/input/stream.c
index bf72c7a1536ded6f1c7ea6081da502876aaf37d6..0598a30c43dd4a274c07a40d2fb2d55719ab69e7 100644 (file)
--- a/src/input/stream.c
+++ b/src/input/stream.c
@@ -1900,7 +1900,7 @@ block_t *stream_Block( stream_t *s, int i_size )
     if( i_size <= 0 ) return NULL;
 
     /* emulate block read */
-    block_t *p_bk = block_New( s, i_size );
+    block_t *p_bk = block_Alloc( i_size );
     if( p_bk )
     {
         int i_read = stream_Read( s, p_bk->p_buffer, i_size );
@@ -1938,7 +1938,7 @@ block_t *stream_BlockRemaining( stream_t *s, int i_max_size )
     if( i_allocate <= 0 )
         return NULL;
 
-    block_t *p_block = block_New( s, i_allocate );
+    block_t *p_block = block_Alloc( i_allocate );
     int i_index = 0;
     while( p_block )
     {

diff --git a/src/misc/image.c b/src/misc/image.c
index 3f55ef687996b5c75c1591349537c46aecdad9e8..2ce3f9ca691c42c6de34f7fcce52cd37fdd0b1a1 100644 (file)
--- a/src/misc/image.c
+++ b/src/misc/image.c
@@ -240,7 +240,7 @@ static picture_t *ImageReadUrl( image_handler_t *p_image, const char *psz_url,
 
     i_size = stream_Size( p_stream );
 
-    p_block = block_New( p_image->p_parent, i_size );
+    p_block = block_Alloc( i_size );
 
     stream_Read( p_stream, p_block->p_buffer, i_size );