minor mods
[melted] / src / modules / core / producer_ppm.c
1 /*
2 * producer_ppm.c -- simple ppm test case
3 * Copyright (C) 2003-2004 Ushodaya Enterprises Limited
4 * Author: Charles Yates <charles.yates@pandora.be>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software Foundation,
18 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 */
20
21 #include "producer_ppm.h"
22
23 #include <framework/mlt_frame.h>
24
25 #include <stdlib.h>
26 #include <string.h>
27
28 typedef struct producer_ppm_s *producer_ppm;
29
30 struct producer_ppm_s
31 {
32 struct mlt_producer_s parent;
33 char *command;
34 FILE *video;
35 FILE *audio;
36 uint64_t expected;
37 };
38
39 static int producer_get_frame( mlt_producer producer, mlt_frame_ptr frame, int index );
40 static void producer_close( mlt_producer parent );
41
42 mlt_producer producer_ppm_init( void *command )
43 {
44 producer_ppm this = calloc( sizeof( struct producer_ppm_s ), 1 );
45 if ( this != NULL && mlt_producer_init( &this->parent, this ) == 0 )
46 {
47 mlt_producer producer = &this->parent;
48 mlt_properties properties = mlt_producer_properties( producer );
49
50 producer->get_frame = producer_get_frame;
51 producer->close = producer_close;
52
53 if ( command != NULL )
54 {
55 mlt_properties_set( properties, "resource", command );
56 this->command = strdup( command );
57 }
58 else
59 {
60 mlt_properties_set( properties, "resource", "ppm test" );
61 }
62
63 return producer;
64 }
65 free( this );
66 return NULL;
67 }
68
69 static int producer_get_image( mlt_frame this, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable )
70 {
71 // Get the frames properties
72 mlt_properties properties = mlt_frame_properties( this );
73
74 if ( mlt_properties_get_int( properties, "has_image" ) )
75 {
76 // Get the RGB image
77 uint8_t *rgb = mlt_properties_get_data( properties, "image", NULL );
78
79 // Get width and height
80 *width = mlt_properties_get_int( properties, "width" );
81 *height = mlt_properties_get_int( properties, "height" );
82
83 // Convert to requested format
84 if ( *format == mlt_image_yuv422 )
85 {
86 uint8_t *image = mlt_pool_alloc( *width * ( *height + 1 ) * 2 );
87 mlt_convert_rgb24_to_yuv422( rgb, *width, *height, *width * 3, image );
88 mlt_properties_set_data( properties, "image", image, *width * ( *height + 1 ) * 2, ( mlt_destructor )mlt_pool_release, NULL );
89 *buffer = image;
90 }
91 else if ( *format == mlt_image_rgb24 )
92 {
93 *buffer = rgb;
94 }
95 }
96 else
97 {
98 mlt_frame_get_image( this, buffer, format, width, height, writable );
99 }
100
101 return 0;
102 }
103
104 FILE *producer_ppm_run_video( producer_ppm this )
105 {
106 if ( this->video == NULL )
107 {
108 if ( this->command == NULL )
109 {
110 this->video = popen( "image2raw -k -r 25 -ppm /usr/share/pixmaps/*.png", "r" );
111 }
112 else
113 {
114 char command[ 1024 ];
115 float fps = mlt_producer_get_fps( &this->parent );
116 float position = mlt_producer_position( &this->parent );
117 sprintf( command, "ffmpeg -i \"%s\" -ss %f -f imagepipe -r %f -img ppm - 2>/dev/null", this->command, position, fps );
118 this->video = popen( command, "r" );
119 }
120 }
121 return this->video;
122 }
123
124 FILE *producer_ppm_run_audio( producer_ppm this )
125 {
126 if ( this->audio == NULL )
127 {
128 if ( this->command != NULL )
129 {
130 char command[ 1024 ];
131 float position = mlt_producer_position( &this->parent );
132 sprintf( command, "ffmpeg -i \"%s\" -ss %f -f s16le -ar 48000 -ac 2 - 2>/dev/null", this->command, position );
133 this->audio = popen( command, "r" );
134 }
135 }
136 return this->audio;
137 }
138
139 static void producer_ppm_position( producer_ppm this, uint64_t requested )
140 {
141 if ( requested != this->expected )
142 {
143 if ( this->video != NULL )
144 pclose( this->video );
145 this->video = NULL;
146 if ( this->audio != NULL )
147 pclose( this->audio );
148 this->audio = NULL;
149 }
150
151 // This is the next frame we expect
152 this->expected = mlt_producer_frame( &this->parent ) + 1;
153
154 // Open the pipe
155 this->video = producer_ppm_run_video( this );
156
157 // Open the audio pipe
158 this->audio = producer_ppm_run_audio( this );
159
160 }
161
162 static int producer_get_audio( mlt_frame this, int16_t **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples )
163 {
164 // Get the frames properties
165 mlt_properties properties = mlt_frame_properties( this );
166
167 FILE *pipe = mlt_properties_get_data( properties, "audio.pipe", NULL );
168
169 *frequency = 48000;
170 *channels = 2;
171 *samples = 1920;
172
173 // Size
174 int size = *samples * *channels * 2;
175
176 // Allocate an image
177 *buffer = malloc( size );
178
179 // Read it
180 if ( pipe != NULL )
181 fread( *buffer, size, 1, pipe );
182 else
183 memset( *buffer, 0, size );
184
185 // Pass the data on the frame properties
186 mlt_properties_set_data( properties, "audio", *buffer, size, free, NULL );
187
188 return 0;
189 }
190
191 static int read_ppm_header( FILE *video, int *width, int *height )
192 {
193 int count = 0;
194 {
195 char temp[ 132 ];
196 fgets( temp, 132, video );
197 fgets( temp, 132, video );
198 count += sscanf( temp, "%d %d", width, height );
199 fgets( temp, 132, video );
200 }
201 return count;
202 }
203
204 static int producer_get_frame( mlt_producer producer, mlt_frame_ptr frame, int index )
205 {
206 producer_ppm this = producer->child;
207 int width;
208 int height;
209
210 // Construct a test frame
211 *frame = mlt_frame_init( );
212
213 // Are we at the position expected?
214 producer_ppm_position( this, mlt_producer_frame( producer ) );
215
216 // Get the frames properties
217 mlt_properties properties = mlt_frame_properties( *frame );
218
219 FILE *video = this->video;
220 FILE *audio = this->audio;
221
222 // Read the video
223 if ( video != NULL && read_ppm_header( video, &width, &height ) == 2 )
224 {
225 // Allocate an image
226 uint8_t *image = mlt_pool_alloc( width * ( height + 1 ) * 3 );
227
228 // Read it
229 fread( image, width * height * 3, 1, video );
230
231 // Pass the data on the frame properties
232 mlt_properties_set_data( properties, "image", image, width * ( height + 1 ) * 3, ( mlt_destructor )mlt_pool_release, NULL );
233 mlt_properties_set_int( properties, "width", width );
234 mlt_properties_set_int( properties, "height", height );
235 mlt_properties_set_int( properties, "has_image", 1 );
236 mlt_properties_set_int( properties, "progressive", 1 );
237 mlt_properties_set_double( properties, "aspect_ratio", 1 );
238
239 // Push the image callback
240 mlt_frame_push_get_image( *frame, producer_get_image );
241 }
242 else
243 {
244 // Push the image callback
245 mlt_frame_push_get_image( *frame, producer_get_image );
246 }
247
248 // Set the audio pipe
249 mlt_properties_set_data( properties, "audio.pipe", audio, 0, NULL, NULL );
250
251 // Hmm - register audio callback
252 ( *frame )->get_audio = producer_get_audio;
253
254 // Update timecode on the frame we're creating
255 mlt_frame_set_position( *frame, mlt_producer_position( producer ) );
256
257 // Calculate the next timecode
258 mlt_producer_prepare_next( producer );
259
260 return 0;
261 }
262
263 static void producer_close( mlt_producer parent )
264 {
265 producer_ppm this = parent->child;
266 if ( this->video )
267 pclose( this->video );
268 if ( this->audio )
269 pclose( this->audio );
270 free( this->command );
271 parent->close = NULL;
272 mlt_producer_close( parent );
273 free( this );
274 }